KILLED proof of input_3pmElMd5Yz.trs # AProVE Commit ID: aff8ecad908e01718a4c36e68d2e55d5e0f16e15 fuhs 20220216 unpublished The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). (0) CpxTRS (1) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms] (2) CpxTRS (3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms] (4) CpxTRS (5) CpxTrsToCdtProof [BOTH BOUNDS(ID, ID), 0 ms] (6) CdtProblem (7) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms] (8) CpxRelTRS (9) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms] (10) CpxRelTRS (11) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms] (12) typed CpxTrs (13) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms] (14) TRS for Loop Detection (15) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms] (16) CpxWeightedTrs (17) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms] (18) CpxTypedWeightedTrs (19) CompletionProof [UPPER BOUND(ID), 0 ms] (20) CpxTypedWeightedCompleteTrs (21) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms] (22) CpxRNTS (23) CompletionProof [UPPER BOUND(ID), 0 ms] (24) CpxTypedWeightedCompleteTrs (25) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (26) CpxTypedWeightedCompleteTrs (27) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 2 ms] (28) CpxRNTS (29) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms] (30) CpxRNTS (31) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms] (32) CpxRNTS (33) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (34) CpxRNTS (35) IntTrsBoundProof [UPPER BOUND(ID), 289 ms] (36) CpxRNTS (37) IntTrsBoundProof [UPPER BOUND(ID), 150 ms] (38) CpxRNTS (39) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (40) CpxRNTS (41) IntTrsBoundProof [UPPER BOUND(ID), 370 ms] (42) CpxRNTS (43) IntTrsBoundProof [UPPER BOUND(ID), 66 ms] (44) CpxRNTS (45) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (46) CpxRNTS (47) IntTrsBoundProof [UPPER BOUND(ID), 1315 ms] (48) CpxRNTS (49) IntTrsBoundProof [UPPER BOUND(ID), 5465 ms] (50) CpxRNTS (51) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms] (52) CdtProblem (53) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (54) CdtProblem (55) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (56) CdtProblem (57) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms] (58) CpxRelTRS (59) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms] (60) CpxTRS (61) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms] (62) CpxWeightedTrs (63) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms] (64) CpxTypedWeightedTrs (65) CompletionProof [UPPER BOUND(ID), 0 ms] (66) CpxTypedWeightedCompleteTrs (67) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (68) CpxTypedWeightedCompleteTrs (69) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms] (70) CpxRNTS (71) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms] (72) CpxRNTS (73) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms] (74) CpxRNTS (75) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (76) CpxRNTS (77) IntTrsBoundProof [UPPER BOUND(ID), 312 ms] (78) CpxRNTS (79) IntTrsBoundProof [UPPER BOUND(ID), 83 ms] (80) CpxRNTS (81) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (82) CpxRNTS (83) IntTrsBoundProof [UPPER BOUND(ID), 232 ms] (84) CpxRNTS (85) IntTrsBoundProof [UPPER BOUND(ID), 74 ms] (86) CpxRNTS (87) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (88) CpxRNTS (89) IntTrsBoundProof [UPPER BOUND(ID), 553 ms] (90) CpxRNTS (91) IntTrsBoundProof [UPPER BOUND(ID), 85 ms] (92) CpxRNTS (93) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (94) CpxRNTS (95) IntTrsBoundProof [UPPER BOUND(ID), 159 ms] (96) CpxRNTS (97) IntTrsBoundProof [UPPER BOUND(ID), 84 ms] (98) CpxRNTS (99) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (100) CpxRNTS (101) IntTrsBoundProof [UPPER BOUND(ID), 2544 ms] (102) CpxRNTS (103) IntTrsBoundProof [UPPER BOUND(ID), 7496 ms] (104) CpxRNTS (105) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (106) CpxRNTS (107) IntTrsBoundProof [UPPER BOUND(ID), 19.4 s] (108) CpxRNTS (109) IntTrsBoundProof [UPPER BOUND(ID), 7002 ms] (110) CpxRNTS (111) CompletionProof [UPPER BOUND(ID), 1 ms] (112) CpxTypedWeightedCompleteTrs (113) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms] (114) CpxRNTS (115) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 155 ms] (116) CdtProblem (117) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 106 ms] (118) CdtProblem (119) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (120) CdtProblem (121) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (122) CdtProblem (123) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (124) CdtProblem (125) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (126) CdtProblem (127) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (128) CdtProblem (129) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (130) CdtProblem (131) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (132) CdtProblem (133) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (134) CdtProblem (135) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (136) CdtProblem (137) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (138) CdtProblem (139) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (140) CdtProblem (141) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (142) CdtProblem (143) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (144) CdtProblem (145) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (146) CdtProblem (147) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (148) CdtProblem (149) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (150) CdtProblem (151) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (152) CdtProblem (153) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (154) CdtProblem (155) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (156) CdtProblem (157) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (158) CdtProblem (159) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 213 ms] (160) CdtProblem (161) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (162) CdtProblem (163) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (164) CdtProblem (165) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (166) CdtProblem (167) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (168) CdtProblem (169) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (170) CdtProblem (171) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (172) CdtProblem (173) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (174) CdtProblem (175) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (176) CdtProblem (177) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (178) CdtProblem (179) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 144 ms] (180) CdtProblem (181) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (182) CdtProblem (183) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (184) CdtProblem (185) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (186) CdtProblem (187) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (188) CdtProblem (189) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (190) CdtProblem (191) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (192) CdtProblem (193) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (194) CdtProblem (195) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (196) CdtProblem (197) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (198) CdtProblem (199) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (200) CdtProblem (201) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (202) CdtProblem (203) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (204) CdtProblem (205) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (206) CdtProblem (207) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (208) CdtProblem (209) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (210) CdtProblem (211) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (212) CdtProblem (213) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (214) CdtProblem (215) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (216) CdtProblem (217) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (218) CdtProblem (219) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (220) CdtProblem (221) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (222) CdtProblem (223) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (224) CdtProblem (225) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (226) CdtProblem (227) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (228) CdtProblem (229) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (230) CdtProblem (231) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (232) CdtProblem (233) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (234) CdtProblem ---------------------------------------- (0) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: select(x', revprefix, Cons(x, xs)) -> mapconsapp(x', permute(revapp(revprefix, Cons(x, xs))), select(x, Cons(x', revprefix), xs)) revapp(Cons(x, xs), rest) -> revapp(xs, Cons(x, rest)) permute(Cons(x, xs)) -> select(x, Nil, xs) mapconsapp(x', Cons(x, xs), rest) -> Cons(Cons(x', x), mapconsapp(x', xs, rest)) select(x, revprefix, Nil) -> mapconsapp(x, permute(revapp(revprefix, Nil)), Nil) revapp(Nil, rest) -> rest permute(Nil) -> Cons(Nil, Nil) mapconsapp(x, Nil, rest) -> rest goal(xs) -> permute(xs) S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (1) RenamingProof (BOTH BOUNDS(ID, ID)) Renamed function symbols to avoid clashes with predefined symbol. ---------------------------------------- (2) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: select(x', revprefix, Cons(x, xs)) -> mapconsapp(x', permute(revapp(revprefix, Cons(x, xs))), select(x, Cons(x', revprefix), xs)) revapp(Cons(x, xs), rest) -> revapp(xs, Cons(x, rest)) permute(Cons(x, xs)) -> select(x, Nil, xs) mapconsapp(x', Cons(x, xs), rest) -> Cons(Cons(x', x), mapconsapp(x', xs, rest)) select(x, revprefix, Nil) -> mapconsapp(x, permute(revapp(revprefix, Nil)), Nil) revapp(Nil, rest) -> rest permute(Nil) -> Cons(Nil, Nil) mapconsapp(x, Nil, rest) -> rest goal(xs) -> permute(xs) S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (3) RelTrsToTrsProof (UPPER BOUND(ID)) transformed relative TRS to TRS ---------------------------------------- (4) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: select(x', revprefix, Cons(x, xs)) -> mapconsapp(x', permute(revapp(revprefix, Cons(x, xs))), select(x, Cons(x', revprefix), xs)) revapp(Cons(x, xs), rest) -> revapp(xs, Cons(x, rest)) permute(Cons(x, xs)) -> select(x, Nil, xs) mapconsapp(x', Cons(x, xs), rest) -> Cons(Cons(x', x), mapconsapp(x', xs, rest)) select(x, revprefix, Nil) -> mapconsapp(x, permute(revapp(revprefix, Nil)), Nil) revapp(Nil, rest) -> rest permute(Nil) -> Cons(Nil, Nil) mapconsapp(x, Nil, rest) -> rest goal(xs) -> permute(xs) S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (5) CpxTrsToCdtProof (BOTH BOUNDS(ID, ID)) Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT ---------------------------------------- (6) Obligation: Complexity Dependency Tuples Problem Rules: select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 goal(z0) -> permute(z0) Tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) REVAPP(Nil, z0) -> c4 PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) PERMUTE(Nil) -> c6 MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) MAPCONSAPP(z0, Nil, z1) -> c8 GOAL(z0) -> c9(PERMUTE(z0)) S tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) REVAPP(Nil, z0) -> c4 PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) PERMUTE(Nil) -> c6 MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) MAPCONSAPP(z0, Nil, z1) -> c8 GOAL(z0) -> c9(PERMUTE(z0)) K tuples:none Defined Rule Symbols: select_3, revapp_2, permute_1, mapconsapp_3, goal_1 Defined Pair Symbols: SELECT_3, REVAPP_2, PERMUTE_1, MAPCONSAPP_3, GOAL_1 Compound Symbols: c_3, c1_2, c2_3, c3_1, c4, c5_1, c6, c7_1, c8, c9_1 ---------------------------------------- (7) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID)) Converted S to standard rules, and D \ S as well as R to relative rules. ---------------------------------------- (8) Obligation: The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) REVAPP(Nil, z0) -> c4 PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) PERMUTE(Nil) -> c6 MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) MAPCONSAPP(z0, Nil, z1) -> c8 GOAL(z0) -> c9(PERMUTE(z0)) The (relative) TRS S consists of the following rules: select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 goal(z0) -> permute(z0) Rewrite Strategy: INNERMOST ---------------------------------------- (9) RenamingProof (BOTH BOUNDS(ID, ID)) Renamed function symbols to avoid clashes with predefined symbol. ---------------------------------------- (10) Obligation: The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) REVAPP(Nil, z0) -> c4 PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) PERMUTE(Nil) -> c6 MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) MAPCONSAPP(z0, Nil, z1) -> c8 GOAL(z0) -> c9(PERMUTE(z0)) The (relative) TRS S consists of the following rules: select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 goal(z0) -> permute(z0) Rewrite Strategy: INNERMOST ---------------------------------------- (11) TypeInferenceProof (BOTH BOUNDS(ID, ID)) Inferred types. ---------------------------------------- (12) Obligation: Innermost TRS: Rules: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) REVAPP(Nil, z0) -> c4 PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) PERMUTE(Nil) -> c6 MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) MAPCONSAPP(z0, Nil, z1) -> c8 GOAL(z0) -> c9(PERMUTE(z0)) select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 goal(z0) -> permute(z0) Types: SELECT :: Cons:Nil -> Cons:Nil -> Cons:Nil -> c:c1:c2 Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil c :: c7:c8 -> c5:c6 -> c3:c4 -> c:c1:c2 MAPCONSAPP :: Cons:Nil -> Cons:Nil -> Cons:Nil -> c7:c8 permute :: Cons:Nil -> Cons:Nil revapp :: Cons:Nil -> Cons:Nil -> Cons:Nil select :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil PERMUTE :: Cons:Nil -> c5:c6 REVAPP :: Cons:Nil -> Cons:Nil -> c3:c4 c1 :: c7:c8 -> c:c1:c2 -> c:c1:c2 Nil :: Cons:Nil c2 :: c7:c8 -> c5:c6 -> c3:c4 -> c:c1:c2 c3 :: c3:c4 -> c3:c4 c4 :: c3:c4 c5 :: c:c1:c2 -> c5:c6 c6 :: c5:c6 c7 :: c7:c8 -> c7:c8 c8 :: c7:c8 GOAL :: Cons:Nil -> c9 c9 :: c5:c6 -> c9 mapconsapp :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil goal :: Cons:Nil -> Cons:Nil hole_c:c1:c21_10 :: c:c1:c2 hole_Cons:Nil2_10 :: Cons:Nil hole_c7:c83_10 :: c7:c8 hole_c5:c64_10 :: c5:c6 hole_c3:c45_10 :: c3:c4 hole_c96_10 :: c9 gen_c:c1:c27_10 :: Nat -> c:c1:c2 gen_Cons:Nil8_10 :: Nat -> Cons:Nil gen_c7:c89_10 :: Nat -> c7:c8 gen_c3:c410_10 :: Nat -> c3:c4 ---------------------------------------- (13) RelTrsToDecreasingLoopProblemProof (LOWER BOUND(ID)) Transformed a relative TRS into a decreasing-loop problem. ---------------------------------------- (14) Obligation: Analyzing the following TRS for decreasing loops: The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) REVAPP(Nil, z0) -> c4 PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) PERMUTE(Nil) -> c6 MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) MAPCONSAPP(z0, Nil, z1) -> c8 GOAL(z0) -> c9(PERMUTE(z0)) The (relative) TRS S consists of the following rules: select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 goal(z0) -> permute(z0) Rewrite Strategy: INNERMOST ---------------------------------------- (15) RelTrsToWeightedTrsProof (UPPER BOUND(ID)) Transformed relative TRS to weighted TRS ---------------------------------------- (16) Obligation: The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: select(x', revprefix, Cons(x, xs)) -> mapconsapp(x', permute(revapp(revprefix, Cons(x, xs))), select(x, Cons(x', revprefix), xs)) [1] revapp(Cons(x, xs), rest) -> revapp(xs, Cons(x, rest)) [1] permute(Cons(x, xs)) -> select(x, Nil, xs) [1] mapconsapp(x', Cons(x, xs), rest) -> Cons(Cons(x', x), mapconsapp(x', xs, rest)) [1] select(x, revprefix, Nil) -> mapconsapp(x, permute(revapp(revprefix, Nil)), Nil) [1] revapp(Nil, rest) -> rest [1] permute(Nil) -> Cons(Nil, Nil) [1] mapconsapp(x, Nil, rest) -> rest [1] goal(xs) -> permute(xs) [1] Rewrite Strategy: INNERMOST ---------------------------------------- (17) TypeInferenceProof (BOTH BOUNDS(ID, ID)) Infered types. ---------------------------------------- (18) Obligation: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: select(x', revprefix, Cons(x, xs)) -> mapconsapp(x', permute(revapp(revprefix, Cons(x, xs))), select(x, Cons(x', revprefix), xs)) [1] revapp(Cons(x, xs), rest) -> revapp(xs, Cons(x, rest)) [1] permute(Cons(x, xs)) -> select(x, Nil, xs) [1] mapconsapp(x', Cons(x, xs), rest) -> Cons(Cons(x', x), mapconsapp(x', xs, rest)) [1] select(x, revprefix, Nil) -> mapconsapp(x, permute(revapp(revprefix, Nil)), Nil) [1] revapp(Nil, rest) -> rest [1] permute(Nil) -> Cons(Nil, Nil) [1] mapconsapp(x, Nil, rest) -> rest [1] goal(xs) -> permute(xs) [1] The TRS has the following type information: select :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil mapconsapp :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil permute :: Cons:Nil -> Cons:Nil revapp :: Cons:Nil -> Cons:Nil -> Cons:Nil Nil :: Cons:Nil goal :: Cons:Nil -> Cons:Nil Rewrite Strategy: INNERMOST ---------------------------------------- (19) CompletionProof (UPPER BOUND(ID)) The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added: none And the following fresh constants: none ---------------------------------------- (20) Obligation: Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: select(x', revprefix, Cons(x, xs)) -> mapconsapp(x', permute(revapp(revprefix, Cons(x, xs))), select(x, Cons(x', revprefix), xs)) [1] revapp(Cons(x, xs), rest) -> revapp(xs, Cons(x, rest)) [1] permute(Cons(x, xs)) -> select(x, Nil, xs) [1] mapconsapp(x', Cons(x, xs), rest) -> Cons(Cons(x', x), mapconsapp(x', xs, rest)) [1] select(x, revprefix, Nil) -> mapconsapp(x, permute(revapp(revprefix, Nil)), Nil) [1] revapp(Nil, rest) -> rest [1] permute(Nil) -> Cons(Nil, Nil) [1] mapconsapp(x, Nil, rest) -> rest [1] goal(xs) -> permute(xs) [1] The TRS has the following type information: select :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil mapconsapp :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil permute :: Cons:Nil -> Cons:Nil revapp :: Cons:Nil -> Cons:Nil -> Cons:Nil Nil :: Cons:Nil goal :: Cons:Nil -> Cons:Nil Rewrite Strategy: INNERMOST ---------------------------------------- (21) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID)) Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction. The constant constructors are abstracted as follows: Nil => 0 ---------------------------------------- (22) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(xs) :|: xs >= 0, z = xs mapconsapp(z, z', z'') -{ 1 }-> rest :|: x >= 0, z'' = rest, rest >= 0, z = x, z' = 0 mapconsapp(z, z', z'') -{ 1 }-> 1 + (1 + x' + x) + mapconsapp(x', xs, rest) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, x >= 0, z'' = rest, rest >= 0, z = x' permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 1 }-> rest :|: z' = rest, rest >= 0, z = 0 revapp(z, z') -{ 1 }-> revapp(xs, 1 + x + rest) :|: z = 1 + x + xs, xs >= 0, z' = rest, x >= 0, rest >= 0 select(z, z', z'') -{ 1 }-> mapconsapp(x, permute(revapp(revprefix, 0)), 0) :|: z'' = 0, z' = revprefix, x >= 0, revprefix >= 0, z = x select(z, z', z'') -{ 1 }-> mapconsapp(x', permute(revapp(revprefix, 1 + x + xs)), select(x, 1 + x' + revprefix, xs)) :|: xs >= 0, z' = revprefix, x' >= 0, x >= 0, z'' = 1 + x + xs, revprefix >= 0, z = x' Only complete derivations are relevant for the runtime complexity. ---------------------------------------- (23) CompletionProof (UPPER BOUND(ID)) The transformation into a RNTS is sound, since: (a) The obligation is a constructor system where every type has a constant constructor, (b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols: goal_1 (c) The following functions are completely defined: permute_1 revapp_2 select_3 mapconsapp_3 Due to the following rules being added: none And the following fresh constants: none ---------------------------------------- (24) Obligation: Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: select(x', revprefix, Cons(x, xs)) -> mapconsapp(x', permute(revapp(revprefix, Cons(x, xs))), select(x, Cons(x', revprefix), xs)) [1] revapp(Cons(x, xs), rest) -> revapp(xs, Cons(x, rest)) [1] permute(Cons(x, xs)) -> select(x, Nil, xs) [1] mapconsapp(x', Cons(x, xs), rest) -> Cons(Cons(x', x), mapconsapp(x', xs, rest)) [1] select(x, revprefix, Nil) -> mapconsapp(x, permute(revapp(revprefix, Nil)), Nil) [1] revapp(Nil, rest) -> rest [1] permute(Nil) -> Cons(Nil, Nil) [1] mapconsapp(x, Nil, rest) -> rest [1] goal(xs) -> permute(xs) [1] The TRS has the following type information: select :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil mapconsapp :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil permute :: Cons:Nil -> Cons:Nil revapp :: Cons:Nil -> Cons:Nil -> Cons:Nil Nil :: Cons:Nil goal :: Cons:Nil -> Cons:Nil Rewrite Strategy: INNERMOST ---------------------------------------- (25) NarrowingProof (BOTH BOUNDS(ID, ID)) Narrowed the inner basic terms of all right-hand sides by a single narrowing step. ---------------------------------------- (26) Obligation: Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: select(x', Cons(x'', xs'), Cons(x, Cons(x1, xs''))) -> mapconsapp(x', permute(revapp(xs', Cons(x'', Cons(x, Cons(x1, xs''))))), mapconsapp(x, permute(revapp(Cons(x', Cons(x'', xs')), Cons(x1, xs''))), select(x1, Cons(x, Cons(x', Cons(x'', xs'))), xs''))) [3] select(x', Cons(x'', xs'), Cons(x, Nil)) -> mapconsapp(x', permute(revapp(xs', Cons(x'', Cons(x, Nil)))), mapconsapp(x, permute(revapp(Cons(x', Cons(x'', xs')), Nil)), Nil)) [3] select(x', Nil, Cons(x, Cons(x2, xs1))) -> mapconsapp(x', permute(Cons(x, Cons(x2, xs1))), mapconsapp(x, permute(revapp(Cons(x', Nil), Cons(x2, xs1))), select(x2, Cons(x, Cons(x', Nil)), xs1))) [3] select(x', Nil, Cons(x, Nil)) -> mapconsapp(x', permute(Cons(x, Nil)), mapconsapp(x, permute(revapp(Cons(x', Nil), Nil)), Nil)) [3] revapp(Cons(x, xs), rest) -> revapp(xs, Cons(x, rest)) [1] permute(Cons(x, xs)) -> select(x, Nil, xs) [1] mapconsapp(x', Cons(x, xs), rest) -> Cons(Cons(x', x), mapconsapp(x', xs, rest)) [1] select(x, Cons(x3, xs2), Nil) -> mapconsapp(x, permute(revapp(xs2, Cons(x3, Nil))), Nil) [2] select(x, Nil, Nil) -> mapconsapp(x, permute(Nil), Nil) [2] revapp(Nil, rest) -> rest [1] permute(Nil) -> Cons(Nil, Nil) [1] mapconsapp(x, Nil, rest) -> rest [1] goal(xs) -> permute(xs) [1] The TRS has the following type information: select :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil mapconsapp :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil permute :: Cons:Nil -> Cons:Nil revapp :: Cons:Nil -> Cons:Nil -> Cons:Nil Nil :: Cons:Nil goal :: Cons:Nil -> Cons:Nil Rewrite Strategy: INNERMOST ---------------------------------------- (27) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID)) Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction. The constant constructors are abstracted as follows: Nil => 0 ---------------------------------------- (28) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(xs) :|: xs >= 0, z = xs mapconsapp(z, z', z'') -{ 1 }-> rest :|: x >= 0, z'' = rest, rest >= 0, z = x, z' = 0 mapconsapp(z, z', z'') -{ 1 }-> 1 + (1 + x' + x) + mapconsapp(x', xs, rest) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, x >= 0, z'' = rest, rest >= 0, z = x' permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 1 }-> rest :|: z' = rest, rest >= 0, z = 0 revapp(z, z') -{ 1 }-> revapp(xs, 1 + x + rest) :|: z = 1 + x + xs, xs >= 0, z' = rest, x >= 0, rest >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(x, permute(revapp(xs2, 1 + x3 + 0)), 0) :|: z'' = 0, xs2 >= 0, z' = 1 + x3 + xs2, x >= 0, z = x, x3 >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(x, permute(0), 0) :|: z'' = 0, x >= 0, z = x, z' = 0 select(z, z', z'') -{ 3 }-> mapconsapp(x', permute(revapp(xs', 1 + x'' + (1 + x + 0))), mapconsapp(x, permute(revapp(1 + x' + (1 + x'' + xs'), 0)), 0)) :|: z'' = 1 + x + 0, x' >= 0, xs' >= 0, x >= 0, z' = 1 + x'' + xs', x'' >= 0, z = x' select(z, z', z'') -{ 3 }-> mapconsapp(x', permute(revapp(xs', 1 + x'' + (1 + x + (1 + x1 + xs'')))), mapconsapp(x, permute(revapp(1 + x' + (1 + x'' + xs'), 1 + x1 + xs'')), select(x1, 1 + x + (1 + x' + (1 + x'' + xs')), xs''))) :|: x1 >= 0, x' >= 0, xs' >= 0, x >= 0, xs'' >= 0, z'' = 1 + x + (1 + x1 + xs''), z' = 1 + x'' + xs', x'' >= 0, z = x' select(z, z', z'') -{ 3 }-> mapconsapp(x', permute(1 + x + 0), mapconsapp(x, permute(revapp(1 + x' + 0, 0)), 0)) :|: z'' = 1 + x + 0, x' >= 0, x >= 0, z = x', z' = 0 select(z, z', z'') -{ 3 }-> mapconsapp(x', permute(1 + x + (1 + x2 + xs1)), mapconsapp(x, permute(revapp(1 + x' + 0, 1 + x2 + xs1)), select(x2, 1 + x + (1 + x' + 0), xs1))) :|: x' >= 0, x >= 0, z'' = 1 + x + (1 + x2 + xs1), xs1 >= 0, x2 >= 0, z = x', z' = 0 ---------------------------------------- (29) SimplificationProof (BOTH BOUNDS(ID, ID)) Simplified the RNTS by moving equalities from the constraints into the right-hand sides. ---------------------------------------- (30) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(z) :|: z >= 0 mapconsapp(z, z', z'') -{ 1 }-> z'' :|: z >= 0, z'' >= 0, z' = 0 mapconsapp(z, z', z'') -{ 1 }-> 1 + (1 + z + x) + mapconsapp(z, xs, z'') :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0, z'' >= 0 permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 1 }-> revapp(xs, 1 + x + z') :|: z = 1 + x + xs, xs >= 0, x >= 0, z' >= 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(revapp(xs', 1 + x'' + (1 + x + (1 + x1 + xs'')))), mapconsapp(x, permute(revapp(1 + z + (1 + x'' + xs'), 1 + x1 + xs'')), select(x1, 1 + x + (1 + z + (1 + x'' + xs')), xs''))) :|: x1 >= 0, z >= 0, xs' >= 0, x >= 0, xs'' >= 0, z'' = 1 + x + (1 + x1 + xs''), z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(revapp(xs', 1 + x'' + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + x'' + xs'), 0)), 0)) :|: z >= 0, xs' >= 0, z'' - 1 >= 0, z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(revapp(xs2, 1 + x3 + 0)), 0) :|: z'' = 0, xs2 >= 0, z' = 1 + x3 + xs2, z >= 0, x3 >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(1 + x + (1 + x2 + xs1)), mapconsapp(x, permute(revapp(1 + z + 0, 1 + x2 + xs1)), select(x2, 1 + x + (1 + z + 0), xs1))) :|: z >= 0, x >= 0, z'' = 1 + x + (1 + x2 + xs1), xs1 >= 0, x2 >= 0, z' = 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) :|: z >= 0, z'' - 1 >= 0, z' = 0 ---------------------------------------- (31) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID)) Found the following analysis order by SCC decomposition: { revapp } { mapconsapp } { permute, select } { goal } ---------------------------------------- (32) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(z) :|: z >= 0 mapconsapp(z, z', z'') -{ 1 }-> z'' :|: z >= 0, z'' >= 0, z' = 0 mapconsapp(z, z', z'') -{ 1 }-> 1 + (1 + z + x) + mapconsapp(z, xs, z'') :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0, z'' >= 0 permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 1 }-> revapp(xs, 1 + x + z') :|: z = 1 + x + xs, xs >= 0, x >= 0, z' >= 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(revapp(xs', 1 + x'' + (1 + x + (1 + x1 + xs'')))), mapconsapp(x, permute(revapp(1 + z + (1 + x'' + xs'), 1 + x1 + xs'')), select(x1, 1 + x + (1 + z + (1 + x'' + xs')), xs''))) :|: x1 >= 0, z >= 0, xs' >= 0, x >= 0, xs'' >= 0, z'' = 1 + x + (1 + x1 + xs''), z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(revapp(xs', 1 + x'' + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + x'' + xs'), 0)), 0)) :|: z >= 0, xs' >= 0, z'' - 1 >= 0, z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(revapp(xs2, 1 + x3 + 0)), 0) :|: z'' = 0, xs2 >= 0, z' = 1 + x3 + xs2, z >= 0, x3 >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(1 + x + (1 + x2 + xs1)), mapconsapp(x, permute(revapp(1 + z + 0, 1 + x2 + xs1)), select(x2, 1 + x + (1 + z + 0), xs1))) :|: z >= 0, x >= 0, z'' = 1 + x + (1 + x2 + xs1), xs1 >= 0, x2 >= 0, z' = 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) :|: z >= 0, z'' - 1 >= 0, z' = 0 Function symbols to be analyzed: {revapp}, {mapconsapp}, {permute,select}, {goal} ---------------------------------------- (33) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (34) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(z) :|: z >= 0 mapconsapp(z, z', z'') -{ 1 }-> z'' :|: z >= 0, z'' >= 0, z' = 0 mapconsapp(z, z', z'') -{ 1 }-> 1 + (1 + z + x) + mapconsapp(z, xs, z'') :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0, z'' >= 0 permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 1 }-> revapp(xs, 1 + x + z') :|: z = 1 + x + xs, xs >= 0, x >= 0, z' >= 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(revapp(xs', 1 + x'' + (1 + x + (1 + x1 + xs'')))), mapconsapp(x, permute(revapp(1 + z + (1 + x'' + xs'), 1 + x1 + xs'')), select(x1, 1 + x + (1 + z + (1 + x'' + xs')), xs''))) :|: x1 >= 0, z >= 0, xs' >= 0, x >= 0, xs'' >= 0, z'' = 1 + x + (1 + x1 + xs''), z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(revapp(xs', 1 + x'' + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + x'' + xs'), 0)), 0)) :|: z >= 0, xs' >= 0, z'' - 1 >= 0, z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(revapp(xs2, 1 + x3 + 0)), 0) :|: z'' = 0, xs2 >= 0, z' = 1 + x3 + xs2, z >= 0, x3 >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(1 + x + (1 + x2 + xs1)), mapconsapp(x, permute(revapp(1 + z + 0, 1 + x2 + xs1)), select(x2, 1 + x + (1 + z + 0), xs1))) :|: z >= 0, x >= 0, z'' = 1 + x + (1 + x2 + xs1), xs1 >= 0, x2 >= 0, z' = 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) :|: z >= 0, z'' - 1 >= 0, z' = 0 Function symbols to be analyzed: {revapp}, {mapconsapp}, {permute,select}, {goal} ---------------------------------------- (35) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: revapp after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z + z' ---------------------------------------- (36) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(z) :|: z >= 0 mapconsapp(z, z', z'') -{ 1 }-> z'' :|: z >= 0, z'' >= 0, z' = 0 mapconsapp(z, z', z'') -{ 1 }-> 1 + (1 + z + x) + mapconsapp(z, xs, z'') :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0, z'' >= 0 permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 1 }-> revapp(xs, 1 + x + z') :|: z = 1 + x + xs, xs >= 0, x >= 0, z' >= 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(revapp(xs', 1 + x'' + (1 + x + (1 + x1 + xs'')))), mapconsapp(x, permute(revapp(1 + z + (1 + x'' + xs'), 1 + x1 + xs'')), select(x1, 1 + x + (1 + z + (1 + x'' + xs')), xs''))) :|: x1 >= 0, z >= 0, xs' >= 0, x >= 0, xs'' >= 0, z'' = 1 + x + (1 + x1 + xs''), z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(revapp(xs', 1 + x'' + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + x'' + xs'), 0)), 0)) :|: z >= 0, xs' >= 0, z'' - 1 >= 0, z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(revapp(xs2, 1 + x3 + 0)), 0) :|: z'' = 0, xs2 >= 0, z' = 1 + x3 + xs2, z >= 0, x3 >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(1 + x + (1 + x2 + xs1)), mapconsapp(x, permute(revapp(1 + z + 0, 1 + x2 + xs1)), select(x2, 1 + x + (1 + z + 0), xs1))) :|: z >= 0, x >= 0, z'' = 1 + x + (1 + x2 + xs1), xs1 >= 0, x2 >= 0, z' = 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) :|: z >= 0, z'' - 1 >= 0, z' = 0 Function symbols to be analyzed: {revapp}, {mapconsapp}, {permute,select}, {goal} Previous analysis results are: revapp: runtime: ?, size: O(n^1) [z + z'] ---------------------------------------- (37) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: revapp after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z ---------------------------------------- (38) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(z) :|: z >= 0 mapconsapp(z, z', z'') -{ 1 }-> z'' :|: z >= 0, z'' >= 0, z' = 0 mapconsapp(z, z', z'') -{ 1 }-> 1 + (1 + z + x) + mapconsapp(z, xs, z'') :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0, z'' >= 0 permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 1 }-> revapp(xs, 1 + x + z') :|: z = 1 + x + xs, xs >= 0, x >= 0, z' >= 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(revapp(xs', 1 + x'' + (1 + x + (1 + x1 + xs'')))), mapconsapp(x, permute(revapp(1 + z + (1 + x'' + xs'), 1 + x1 + xs'')), select(x1, 1 + x + (1 + z + (1 + x'' + xs')), xs''))) :|: x1 >= 0, z >= 0, xs' >= 0, x >= 0, xs'' >= 0, z'' = 1 + x + (1 + x1 + xs''), z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(revapp(xs', 1 + x'' + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + x'' + xs'), 0)), 0)) :|: z >= 0, xs' >= 0, z'' - 1 >= 0, z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(revapp(xs2, 1 + x3 + 0)), 0) :|: z'' = 0, xs2 >= 0, z' = 1 + x3 + xs2, z >= 0, x3 >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(1 + x + (1 + x2 + xs1)), mapconsapp(x, permute(revapp(1 + z + 0, 1 + x2 + xs1)), select(x2, 1 + x + (1 + z + 0), xs1))) :|: z >= 0, x >= 0, z'' = 1 + x + (1 + x2 + xs1), xs1 >= 0, x2 >= 0, z' = 0 select(z, z', z'') -{ 3 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) :|: z >= 0, z'' - 1 >= 0, z' = 0 Function symbols to be analyzed: {mapconsapp}, {permute,select}, {goal} Previous analysis results are: revapp: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] ---------------------------------------- (39) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (40) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(z) :|: z >= 0 mapconsapp(z, z', z'') -{ 1 }-> z'' :|: z >= 0, z'' >= 0, z' = 0 mapconsapp(z, z', z'') -{ 1 }-> 1 + (1 + z + x) + mapconsapp(z, xs, z'') :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0, z'' >= 0 permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 2 + xs }-> s4 :|: s4 >= 0, s4 <= xs + (1 + x + z'), z = 1 + x + xs, xs >= 0, x >= 0, z' >= 0 revapp(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 select(z, z', z'') -{ 7 + x'' + 2*xs' + z }-> mapconsapp(z, permute(s), mapconsapp(x, permute(s'), select(x1, 1 + x + (1 + z + (1 + x'' + xs')), xs''))) :|: s >= 0, s <= xs' + (1 + x'' + (1 + x + (1 + x1 + xs''))), s' >= 0, s' <= 1 + z + (1 + x'' + xs') + (1 + x1 + xs''), x1 >= 0, z >= 0, xs' >= 0, x >= 0, xs'' >= 0, z'' = 1 + x + (1 + x1 + xs''), z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 7 + x'' + 2*xs' + z }-> mapconsapp(z, permute(s''), mapconsapp(z'' - 1, permute(s1), 0)) :|: s'' >= 0, s'' <= xs' + (1 + x'' + (1 + (z'' - 1) + 0)), s1 >= 0, s1 <= 1 + z + (1 + x'' + xs') + 0, z >= 0, xs' >= 0, z'' - 1 >= 0, z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 3 + xs2 }-> mapconsapp(z, permute(s5), 0) :|: s5 >= 0, s5 <= xs2 + (1 + x3 + 0), z'' = 0, xs2 >= 0, z' = 1 + x3 + xs2, z >= 0, x3 >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 5 + z }-> mapconsapp(z, permute(1 + x + (1 + x2 + xs1)), mapconsapp(x, permute(s2), select(x2, 1 + x + (1 + z + 0), xs1))) :|: s2 >= 0, s2 <= 1 + z + 0 + (1 + x2 + xs1), z >= 0, x >= 0, z'' = 1 + x + (1 + x2 + xs1), xs1 >= 0, x2 >= 0, z' = 0 select(z, z', z'') -{ 5 + z }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s3), 0)) :|: s3 >= 0, s3 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 Function symbols to be analyzed: {mapconsapp}, {permute,select}, {goal} Previous analysis results are: revapp: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] ---------------------------------------- (41) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: mapconsapp after applying outer abstraction to obtain an ITS, resulting in: O(n^2) with polynomial bound: z*z' + z' + z'^2 + z'' ---------------------------------------- (42) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(z) :|: z >= 0 mapconsapp(z, z', z'') -{ 1 }-> z'' :|: z >= 0, z'' >= 0, z' = 0 mapconsapp(z, z', z'') -{ 1 }-> 1 + (1 + z + x) + mapconsapp(z, xs, z'') :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0, z'' >= 0 permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 2 + xs }-> s4 :|: s4 >= 0, s4 <= xs + (1 + x + z'), z = 1 + x + xs, xs >= 0, x >= 0, z' >= 0 revapp(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 select(z, z', z'') -{ 7 + x'' + 2*xs' + z }-> mapconsapp(z, permute(s), mapconsapp(x, permute(s'), select(x1, 1 + x + (1 + z + (1 + x'' + xs')), xs''))) :|: s >= 0, s <= xs' + (1 + x'' + (1 + x + (1 + x1 + xs''))), s' >= 0, s' <= 1 + z + (1 + x'' + xs') + (1 + x1 + xs''), x1 >= 0, z >= 0, xs' >= 0, x >= 0, xs'' >= 0, z'' = 1 + x + (1 + x1 + xs''), z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 7 + x'' + 2*xs' + z }-> mapconsapp(z, permute(s''), mapconsapp(z'' - 1, permute(s1), 0)) :|: s'' >= 0, s'' <= xs' + (1 + x'' + (1 + (z'' - 1) + 0)), s1 >= 0, s1 <= 1 + z + (1 + x'' + xs') + 0, z >= 0, xs' >= 0, z'' - 1 >= 0, z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 3 + xs2 }-> mapconsapp(z, permute(s5), 0) :|: s5 >= 0, s5 <= xs2 + (1 + x3 + 0), z'' = 0, xs2 >= 0, z' = 1 + x3 + xs2, z >= 0, x3 >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 5 + z }-> mapconsapp(z, permute(1 + x + (1 + x2 + xs1)), mapconsapp(x, permute(s2), select(x2, 1 + x + (1 + z + 0), xs1))) :|: s2 >= 0, s2 <= 1 + z + 0 + (1 + x2 + xs1), z >= 0, x >= 0, z'' = 1 + x + (1 + x2 + xs1), xs1 >= 0, x2 >= 0, z' = 0 select(z, z', z'') -{ 5 + z }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s3), 0)) :|: s3 >= 0, s3 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 Function symbols to be analyzed: {mapconsapp}, {permute,select}, {goal} Previous analysis results are: revapp: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] mapconsapp: runtime: ?, size: O(n^2) [z*z' + z' + z'^2 + z''] ---------------------------------------- (43) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: mapconsapp after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z' ---------------------------------------- (44) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(z) :|: z >= 0 mapconsapp(z, z', z'') -{ 1 }-> z'' :|: z >= 0, z'' >= 0, z' = 0 mapconsapp(z, z', z'') -{ 1 }-> 1 + (1 + z + x) + mapconsapp(z, xs, z'') :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0, z'' >= 0 permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 2 + xs }-> s4 :|: s4 >= 0, s4 <= xs + (1 + x + z'), z = 1 + x + xs, xs >= 0, x >= 0, z' >= 0 revapp(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 select(z, z', z'') -{ 7 + x'' + 2*xs' + z }-> mapconsapp(z, permute(s), mapconsapp(x, permute(s'), select(x1, 1 + x + (1 + z + (1 + x'' + xs')), xs''))) :|: s >= 0, s <= xs' + (1 + x'' + (1 + x + (1 + x1 + xs''))), s' >= 0, s' <= 1 + z + (1 + x'' + xs') + (1 + x1 + xs''), x1 >= 0, z >= 0, xs' >= 0, x >= 0, xs'' >= 0, z'' = 1 + x + (1 + x1 + xs''), z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 7 + x'' + 2*xs' + z }-> mapconsapp(z, permute(s''), mapconsapp(z'' - 1, permute(s1), 0)) :|: s'' >= 0, s'' <= xs' + (1 + x'' + (1 + (z'' - 1) + 0)), s1 >= 0, s1 <= 1 + z + (1 + x'' + xs') + 0, z >= 0, xs' >= 0, z'' - 1 >= 0, z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 3 + xs2 }-> mapconsapp(z, permute(s5), 0) :|: s5 >= 0, s5 <= xs2 + (1 + x3 + 0), z'' = 0, xs2 >= 0, z' = 1 + x3 + xs2, z >= 0, x3 >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 5 + z }-> mapconsapp(z, permute(1 + x + (1 + x2 + xs1)), mapconsapp(x, permute(s2), select(x2, 1 + x + (1 + z + 0), xs1))) :|: s2 >= 0, s2 <= 1 + z + 0 + (1 + x2 + xs1), z >= 0, x >= 0, z'' = 1 + x + (1 + x2 + xs1), xs1 >= 0, x2 >= 0, z' = 0 select(z, z', z'') -{ 5 + z }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s3), 0)) :|: s3 >= 0, s3 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 Function symbols to be analyzed: {permute,select}, {goal} Previous analysis results are: revapp: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] mapconsapp: runtime: O(n^1) [1 + z'], size: O(n^2) [z*z' + z' + z'^2 + z''] ---------------------------------------- (45) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (46) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(z) :|: z >= 0 mapconsapp(z, z', z'') -{ 1 }-> z'' :|: z >= 0, z'' >= 0, z' = 0 mapconsapp(z, z', z'') -{ 2 + xs }-> 1 + (1 + z + x) + s6 :|: s6 >= 0, s6 <= xs * z + xs * xs + xs + z'', xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0, z'' >= 0 permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 2 + xs }-> s4 :|: s4 >= 0, s4 <= xs + (1 + x + z'), z = 1 + x + xs, xs >= 0, x >= 0, z' >= 0 revapp(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 select(z, z', z'') -{ 7 + x'' + 2*xs' + z }-> mapconsapp(z, permute(s), mapconsapp(x, permute(s'), select(x1, 1 + x + (1 + z + (1 + x'' + xs')), xs''))) :|: s >= 0, s <= xs' + (1 + x'' + (1 + x + (1 + x1 + xs''))), s' >= 0, s' <= 1 + z + (1 + x'' + xs') + (1 + x1 + xs''), x1 >= 0, z >= 0, xs' >= 0, x >= 0, xs'' >= 0, z'' = 1 + x + (1 + x1 + xs''), z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 7 + x'' + 2*xs' + z }-> mapconsapp(z, permute(s''), mapconsapp(z'' - 1, permute(s1), 0)) :|: s'' >= 0, s'' <= xs' + (1 + x'' + (1 + (z'' - 1) + 0)), s1 >= 0, s1 <= 1 + z + (1 + x'' + xs') + 0, z >= 0, xs' >= 0, z'' - 1 >= 0, z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 3 + xs2 }-> mapconsapp(z, permute(s5), 0) :|: s5 >= 0, s5 <= xs2 + (1 + x3 + 0), z'' = 0, xs2 >= 0, z' = 1 + x3 + xs2, z >= 0, x3 >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 5 + z }-> mapconsapp(z, permute(1 + x + (1 + x2 + xs1)), mapconsapp(x, permute(s2), select(x2, 1 + x + (1 + z + 0), xs1))) :|: s2 >= 0, s2 <= 1 + z + 0 + (1 + x2 + xs1), z >= 0, x >= 0, z'' = 1 + x + (1 + x2 + xs1), xs1 >= 0, x2 >= 0, z' = 0 select(z, z', z'') -{ 5 + z }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s3), 0)) :|: s3 >= 0, s3 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 Function symbols to be analyzed: {permute,select}, {goal} Previous analysis results are: revapp: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] mapconsapp: runtime: O(n^1) [1 + z'], size: O(n^2) [z*z' + z' + z'^2 + z''] ---------------------------------------- (47) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: select after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (48) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(z) :|: z >= 0 mapconsapp(z, z', z'') -{ 1 }-> z'' :|: z >= 0, z'' >= 0, z' = 0 mapconsapp(z, z', z'') -{ 2 + xs }-> 1 + (1 + z + x) + s6 :|: s6 >= 0, s6 <= xs * z + xs * xs + xs + z'', xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0, z'' >= 0 permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 2 + xs }-> s4 :|: s4 >= 0, s4 <= xs + (1 + x + z'), z = 1 + x + xs, xs >= 0, x >= 0, z' >= 0 revapp(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 select(z, z', z'') -{ 7 + x'' + 2*xs' + z }-> mapconsapp(z, permute(s), mapconsapp(x, permute(s'), select(x1, 1 + x + (1 + z + (1 + x'' + xs')), xs''))) :|: s >= 0, s <= xs' + (1 + x'' + (1 + x + (1 + x1 + xs''))), s' >= 0, s' <= 1 + z + (1 + x'' + xs') + (1 + x1 + xs''), x1 >= 0, z >= 0, xs' >= 0, x >= 0, xs'' >= 0, z'' = 1 + x + (1 + x1 + xs''), z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 7 + x'' + 2*xs' + z }-> mapconsapp(z, permute(s''), mapconsapp(z'' - 1, permute(s1), 0)) :|: s'' >= 0, s'' <= xs' + (1 + x'' + (1 + (z'' - 1) + 0)), s1 >= 0, s1 <= 1 + z + (1 + x'' + xs') + 0, z >= 0, xs' >= 0, z'' - 1 >= 0, z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 3 + xs2 }-> mapconsapp(z, permute(s5), 0) :|: s5 >= 0, s5 <= xs2 + (1 + x3 + 0), z'' = 0, xs2 >= 0, z' = 1 + x3 + xs2, z >= 0, x3 >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 5 + z }-> mapconsapp(z, permute(1 + x + (1 + x2 + xs1)), mapconsapp(x, permute(s2), select(x2, 1 + x + (1 + z + 0), xs1))) :|: s2 >= 0, s2 <= 1 + z + 0 + (1 + x2 + xs1), z >= 0, x >= 0, z'' = 1 + x + (1 + x2 + xs1), xs1 >= 0, x2 >= 0, z' = 0 select(z, z', z'') -{ 5 + z }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s3), 0)) :|: s3 >= 0, s3 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 Function symbols to be analyzed: {permute,select}, {goal} Previous analysis results are: revapp: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] mapconsapp: runtime: O(n^1) [1 + z'], size: O(n^2) [z*z' + z' + z'^2 + z''] permute: runtime: ?, size: INF select: runtime: ?, size: INF ---------------------------------------- (49) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: permute after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (50) Obligation: Complexity RNTS consisting of the following rules: goal(z) -{ 1 }-> permute(z) :|: z >= 0 mapconsapp(z, z', z'') -{ 1 }-> z'' :|: z >= 0, z'' >= 0, z' = 0 mapconsapp(z, z', z'') -{ 2 + xs }-> 1 + (1 + z + x) + s6 :|: s6 >= 0, s6 <= xs * z + xs * xs + xs + z'', xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0, z'' >= 0 permute(z) -{ 1 }-> select(x, 0, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 permute(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 2 + xs }-> s4 :|: s4 >= 0, s4 <= xs + (1 + x + z'), z = 1 + x + xs, xs >= 0, x >= 0, z' >= 0 revapp(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 select(z, z', z'') -{ 7 + x'' + 2*xs' + z }-> mapconsapp(z, permute(s), mapconsapp(x, permute(s'), select(x1, 1 + x + (1 + z + (1 + x'' + xs')), xs''))) :|: s >= 0, s <= xs' + (1 + x'' + (1 + x + (1 + x1 + xs''))), s' >= 0, s' <= 1 + z + (1 + x'' + xs') + (1 + x1 + xs''), x1 >= 0, z >= 0, xs' >= 0, x >= 0, xs'' >= 0, z'' = 1 + x + (1 + x1 + xs''), z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 7 + x'' + 2*xs' + z }-> mapconsapp(z, permute(s''), mapconsapp(z'' - 1, permute(s1), 0)) :|: s'' >= 0, s'' <= xs' + (1 + x'' + (1 + (z'' - 1) + 0)), s1 >= 0, s1 <= 1 + z + (1 + x'' + xs') + 0, z >= 0, xs' >= 0, z'' - 1 >= 0, z' = 1 + x'' + xs', x'' >= 0 select(z, z', z'') -{ 3 + xs2 }-> mapconsapp(z, permute(s5), 0) :|: s5 >= 0, s5 <= xs2 + (1 + x3 + 0), z'' = 0, xs2 >= 0, z' = 1 + x3 + xs2, z >= 0, x3 >= 0 select(z, z', z'') -{ 2 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 5 + z }-> mapconsapp(z, permute(1 + x + (1 + x2 + xs1)), mapconsapp(x, permute(s2), select(x2, 1 + x + (1 + z + 0), xs1))) :|: s2 >= 0, s2 <= 1 + z + 0 + (1 + x2 + xs1), z >= 0, x >= 0, z'' = 1 + x + (1 + x2 + xs1), xs1 >= 0, x2 >= 0, z' = 0 select(z, z', z'') -{ 5 + z }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s3), 0)) :|: s3 >= 0, s3 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 Function symbols to be analyzed: {permute,select}, {goal} Previous analysis results are: revapp: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] mapconsapp: runtime: O(n^1) [1 + z'], size: O(n^2) [z*z' + z' + z'^2 + z''] permute: runtime: INF, size: INF select: runtime: ?, size: INF ---------------------------------------- (51) CpxTrsToCdtProof (UPPER BOUND(ID)) Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT ---------------------------------------- (52) Obligation: Complexity Dependency Tuples Problem Rules: select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 goal(z0) -> permute(z0) Tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) REVAPP(Nil, z0) -> c4 PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) PERMUTE(Nil) -> c6 MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) MAPCONSAPP(z0, Nil, z1) -> c8 GOAL(z0) -> c9(PERMUTE(z0)) S tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) REVAPP(Nil, z0) -> c4 PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) PERMUTE(Nil) -> c6 MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) MAPCONSAPP(z0, Nil, z1) -> c8 GOAL(z0) -> c9(PERMUTE(z0)) K tuples:none Defined Rule Symbols: select_3, revapp_2, permute_1, mapconsapp_3, goal_1 Defined Pair Symbols: SELECT_3, REVAPP_2, PERMUTE_1, MAPCONSAPP_3, GOAL_1 Compound Symbols: c_3, c1_2, c2_3, c3_1, c4, c5_1, c6, c7_1, c8, c9_1 ---------------------------------------- (53) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: GOAL(z0) -> c9(PERMUTE(z0)) Removed 3 trailing nodes: REVAPP(Nil, z0) -> c4 MAPCONSAPP(z0, Nil, z1) -> c8 PERMUTE(Nil) -> c6 ---------------------------------------- (54) Obligation: Complexity Dependency Tuples Problem Rules: select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 goal(z0) -> permute(z0) Tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) S tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) K tuples:none Defined Rule Symbols: select_3, revapp_2, permute_1, mapconsapp_3, goal_1 Defined Pair Symbols: SELECT_3, REVAPP_2, PERMUTE_1, MAPCONSAPP_3 Compound Symbols: c_3, c1_2, c2_3, c3_1, c5_1, c7_1 ---------------------------------------- (55) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: goal(z0) -> permute(z0) ---------------------------------------- (56) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) S tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) K tuples:none Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: SELECT_3, REVAPP_2, PERMUTE_1, MAPCONSAPP_3 Compound Symbols: c_3, c1_2, c2_3, c3_1, c5_1, c7_1 ---------------------------------------- (57) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID)) Converted S to standard rules, and D \ S as well as R to relative rules. ---------------------------------------- (58) Obligation: The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) The (relative) TRS S consists of the following rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Rewrite Strategy: INNERMOST ---------------------------------------- (59) RelTrsToTrsProof (UPPER BOUND(ID)) transformed relative TRS to TRS ---------------------------------------- (60) Obligation: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 S is empty. Rewrite Strategy: INNERMOST ---------------------------------------- (61) RelTrsToWeightedTrsProof (BOTH BOUNDS(ID, ID)) Transformed relative TRS to weighted TRS ---------------------------------------- (62) Obligation: The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) [1] SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) [1] SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) [1] REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) [1] PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) [1] MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) [1] permute(Cons(z0, z1)) -> select(z0, Nil, z1) [0] permute(Nil) -> Cons(Nil, Nil) [0] revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) [0] revapp(Nil, z0) -> z0 [0] select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) [0] select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) [0] mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) [0] mapconsapp(z0, Nil, z1) -> z1 [0] Rewrite Strategy: INNERMOST ---------------------------------------- (63) TypeInferenceProof (BOTH BOUNDS(ID, ID)) Infered types. ---------------------------------------- (64) Obligation: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) [1] SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) [1] SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) [1] REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) [1] PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) [1] MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) [1] permute(Cons(z0, z1)) -> select(z0, Nil, z1) [0] permute(Nil) -> Cons(Nil, Nil) [0] revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) [0] revapp(Nil, z0) -> z0 [0] select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) [0] select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) [0] mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) [0] mapconsapp(z0, Nil, z1) -> z1 [0] The TRS has the following type information: SELECT :: Cons:Nil -> Cons:Nil -> Cons:Nil -> c:c1:c2 Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil c :: c7 -> c5 -> c3 -> c:c1:c2 MAPCONSAPP :: Cons:Nil -> Cons:Nil -> Cons:Nil -> c7 permute :: Cons:Nil -> Cons:Nil revapp :: Cons:Nil -> Cons:Nil -> Cons:Nil select :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil PERMUTE :: Cons:Nil -> c5 REVAPP :: Cons:Nil -> Cons:Nil -> c3 c1 :: c7 -> c:c1:c2 -> c:c1:c2 Nil :: Cons:Nil c2 :: c7 -> c5 -> c3 -> c:c1:c2 c3 :: c3 -> c3 c5 :: c:c1:c2 -> c5 c7 :: c7 -> c7 mapconsapp :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil Rewrite Strategy: INNERMOST ---------------------------------------- (65) CompletionProof (UPPER BOUND(ID)) The transformation into a RNTS is sound, since: (a) The obligation is a constructor system where every type has a constant constructor, (b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols: SELECT_3 REVAPP_2 PERMUTE_1 MAPCONSAPP_3 (c) The following functions are completely defined: permute_1 revapp_2 select_3 mapconsapp_3 Due to the following rules being added: permute(v0) -> Nil [0] revapp(v0, v1) -> Nil [0] select(v0, v1, v2) -> Nil [0] mapconsapp(v0, v1, v2) -> Nil [0] And the following fresh constants: const, const1, const2, const3 ---------------------------------------- (66) Obligation: Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) [1] SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) [1] SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) [1] REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) [1] PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) [1] MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) [1] permute(Cons(z0, z1)) -> select(z0, Nil, z1) [0] permute(Nil) -> Cons(Nil, Nil) [0] revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) [0] revapp(Nil, z0) -> z0 [0] select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) [0] select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) [0] mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) [0] mapconsapp(z0, Nil, z1) -> z1 [0] permute(v0) -> Nil [0] revapp(v0, v1) -> Nil [0] select(v0, v1, v2) -> Nil [0] mapconsapp(v0, v1, v2) -> Nil [0] The TRS has the following type information: SELECT :: Cons:Nil -> Cons:Nil -> Cons:Nil -> c:c1:c2 Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil c :: c7 -> c5 -> c3 -> c:c1:c2 MAPCONSAPP :: Cons:Nil -> Cons:Nil -> Cons:Nil -> c7 permute :: Cons:Nil -> Cons:Nil revapp :: Cons:Nil -> Cons:Nil -> Cons:Nil select :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil PERMUTE :: Cons:Nil -> c5 REVAPP :: Cons:Nil -> Cons:Nil -> c3 c1 :: c7 -> c:c1:c2 -> c:c1:c2 Nil :: Cons:Nil c2 :: c7 -> c5 -> c3 -> c:c1:c2 c3 :: c3 -> c3 c5 :: c:c1:c2 -> c5 c7 :: c7 -> c7 mapconsapp :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil const :: c:c1:c2 const1 :: c7 const2 :: c5 const3 :: c3 Rewrite Strategy: INNERMOST ---------------------------------------- (67) NarrowingProof (BOTH BOUNDS(ID, ID)) Narrowed the inner basic terms of all right-hand sides by a single narrowing step. ---------------------------------------- (68) Obligation: Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) [1] SELECT(z0, Cons(z03, z13), Cons(z2, Cons(z22, z32))) -> c1(MAPCONSAPP(z0, permute(revapp(z13, Cons(z03, Cons(z2, Cons(z22, z32))))), mapconsapp(z2, permute(revapp(Cons(z0, Cons(z03, z13)), Cons(z22, z32))), select(z22, Cons(z2, Cons(z0, Cons(z03, z13))), z32))), SELECT(z2, Cons(z0, Cons(z03, z13)), Cons(z22, z32))) [1] SELECT(z0, Cons(z03, z13), Cons(z2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z13, Cons(z03, Cons(z2, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, Cons(z03, z13)), Nil)), Nil)), SELECT(z2, Cons(z0, Cons(z03, z13)), Nil)) [1] SELECT(z0, Cons(z03, z13), Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z13, Cons(z03, Cons(z2, z3)))), Nil), SELECT(z2, Cons(z0, Cons(z03, z13)), z3)) [1] SELECT(z0, Nil, Cons(z2, Cons(z23, z33))) -> c1(MAPCONSAPP(z0, permute(Cons(z2, Cons(z23, z33))), mapconsapp(z2, permute(revapp(Cons(z0, Nil), Cons(z23, z33))), select(z23, Cons(z2, Cons(z0, Nil)), z33))), SELECT(z2, Cons(z0, Nil), Cons(z23, z33))) [1] SELECT(z0, Nil, Cons(z2, Nil)) -> c1(MAPCONSAPP(z0, permute(Cons(z2, Nil)), mapconsapp(z2, permute(revapp(Cons(z0, Nil), Nil)), Nil)), SELECT(z2, Cons(z0, Nil), Nil)) [1] SELECT(z0, Nil, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(Cons(z2, z3)), Nil), SELECT(z2, Cons(z0, Nil), z3)) [1] SELECT(z0, z1, Cons(z2, Cons(z24, z34))) -> c1(MAPCONSAPP(z0, permute(Nil), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z24, z34))), select(z24, Cons(z2, Cons(z0, z1)), z34))), SELECT(z2, Cons(z0, z1), Cons(z24, z34))) [1] SELECT(z0, z1, Cons(z2, Nil)) -> c1(MAPCONSAPP(z0, permute(Nil), mapconsapp(z2, permute(revapp(Cons(z0, z1), Nil)), Nil)), SELECT(z2, Cons(z0, z1), Nil)) [1] SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(Nil), Nil), SELECT(z2, Cons(z0, z1), z3)) [1] SELECT(z0, Cons(z04, z14), Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z14, Cons(z04, Nil))), Nil), PERMUTE(revapp(z14, Cons(z04, Nil))), REVAPP(Cons(z04, z14), Nil)) [1] SELECT(z0, Cons(z04, z14), Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z14, Cons(z04, Nil))), Nil), PERMUTE(Nil), REVAPP(Cons(z04, z14), Nil)) [1] SELECT(z0, Nil, Nil) -> c2(MAPCONSAPP(z0, permute(Nil), Nil), PERMUTE(Nil), REVAPP(Nil, Nil)) [1] SELECT(z0, Nil, Nil) -> c2(MAPCONSAPP(z0, permute(Nil), Nil), PERMUTE(Nil), REVAPP(Nil, Nil)) [1] SELECT(z0, Cons(z05, z15), Nil) -> c2(MAPCONSAPP(z0, permute(Nil), Nil), PERMUTE(revapp(z15, Cons(z05, Nil))), REVAPP(Cons(z05, z15), Nil)) [1] SELECT(z0, Nil, Nil) -> c2(MAPCONSAPP(z0, permute(Nil), Nil), PERMUTE(Nil), REVAPP(Nil, Nil)) [1] SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(Nil), Nil), PERMUTE(Nil), REVAPP(z1, Nil)) [1] REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) [1] PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) [1] MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) [1] permute(Cons(z0, z1)) -> select(z0, Nil, z1) [0] permute(Nil) -> Cons(Nil, Nil) [0] revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) [0] revapp(Nil, z0) -> z0 [0] select(z0, Cons(z06, z16), Cons(z2, Cons(z25, z35))) -> mapconsapp(z0, permute(revapp(z16, Cons(z06, Cons(z2, Cons(z25, z35))))), mapconsapp(z2, permute(revapp(Cons(z0, Cons(z06, z16)), Cons(z25, z35))), select(z25, Cons(z2, Cons(z0, Cons(z06, z16))), z35))) [0] select(z0, Cons(z06, z16), Cons(z2, Nil)) -> mapconsapp(z0, permute(revapp(z16, Cons(z06, Cons(z2, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, Cons(z06, z16)), Nil)), Nil)) [0] select(z0, Cons(z06, z16), Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z16, Cons(z06, Cons(z2, z3)))), Nil) [0] select(z0, Nil, Cons(z2, Cons(z26, z36))) -> mapconsapp(z0, permute(Cons(z2, Cons(z26, z36))), mapconsapp(z2, permute(revapp(Cons(z0, Nil), Cons(z26, z36))), select(z26, Cons(z2, Cons(z0, Nil)), z36))) [0] select(z0, Nil, Cons(z2, Nil)) -> mapconsapp(z0, permute(Cons(z2, Nil)), mapconsapp(z2, permute(revapp(Cons(z0, Nil), Nil)), Nil)) [0] select(z0, Nil, Cons(z2, z3)) -> mapconsapp(z0, permute(Cons(z2, z3)), Nil) [0] select(z0, z1, Cons(z2, Cons(z27, z37))) -> mapconsapp(z0, permute(Nil), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z27, z37))), select(z27, Cons(z2, Cons(z0, z1)), z37))) [0] select(z0, z1, Cons(z2, Nil)) -> mapconsapp(z0, permute(Nil), mapconsapp(z2, permute(revapp(Cons(z0, z1), Nil)), Nil)) [0] select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(Nil), Nil) [0] select(z0, Cons(z07, z17), Nil) -> mapconsapp(z0, permute(revapp(z17, Cons(z07, Nil))), Nil) [0] select(z0, Nil, Nil) -> mapconsapp(z0, permute(Nil), Nil) [0] select(z0, z1, Nil) -> mapconsapp(z0, permute(Nil), Nil) [0] mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) [0] mapconsapp(z0, Nil, z1) -> z1 [0] permute(v0) -> Nil [0] revapp(v0, v1) -> Nil [0] select(v0, v1, v2) -> Nil [0] mapconsapp(v0, v1, v2) -> Nil [0] The TRS has the following type information: SELECT :: Cons:Nil -> Cons:Nil -> Cons:Nil -> c:c1:c2 Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil c :: c7 -> c5 -> c3 -> c:c1:c2 MAPCONSAPP :: Cons:Nil -> Cons:Nil -> Cons:Nil -> c7 permute :: Cons:Nil -> Cons:Nil revapp :: Cons:Nil -> Cons:Nil -> Cons:Nil select :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil PERMUTE :: Cons:Nil -> c5 REVAPP :: Cons:Nil -> Cons:Nil -> c3 c1 :: c7 -> c:c1:c2 -> c:c1:c2 Nil :: Cons:Nil c2 :: c7 -> c5 -> c3 -> c:c1:c2 c3 :: c3 -> c3 c5 :: c:c1:c2 -> c5 c7 :: c7 -> c7 mapconsapp :: Cons:Nil -> Cons:Nil -> Cons:Nil -> Cons:Nil const :: c:c1:c2 const1 :: c7 const2 :: c5 const3 :: c3 Rewrite Strategy: INNERMOST ---------------------------------------- (69) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID)) Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction. The constant constructors are abstracted as follows: Nil => 0 const => 0 const1 => 0 const2 => 0 const3 => 0 ---------------------------------------- (70) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, z2, z3) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z'' = z3, z2 >= 0, z3 >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 }-> 1 + REVAPP(z1, 1 + z0 + z2) :|: z1 >= 0, z' = z2, z0 >= 0, z = 1 + z0 + z1, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(revapp(z13, 1 + z03 + (1 + z2 + z3))), 0) + SELECT(z2, 1 + z0 + (1 + z03 + z13), z3) :|: z = z0, z0 >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(revapp(z13, 1 + z03 + (1 + z2 + 0))), mapconsapp(z2, permute(revapp(1 + z0 + (1 + z03 + z13), 0)), 0)) + SELECT(z2, 1 + z0 + (1 + z03 + z13), 0) :|: z = z0, z'' = 1 + z2 + 0, z0 >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(revapp(z13, 1 + z03 + (1 + z2 + (1 + z22 + z32)))), mapconsapp(z2, permute(revapp(1 + z0 + (1 + z03 + z13), 1 + z22 + z32)), select(z22, 1 + z2 + (1 + z0 + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z0 + (1 + z03 + z13), 1 + z22 + z32) :|: z = z0, z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z0 >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(0), mapconsapp(z2, permute(revapp(1 + z0 + z1, 0)), 0)) + SELECT(z2, 1 + z0 + z1, 0) :|: z = z0, z1 >= 0, z'' = 1 + z2 + 0, z' = z1, z0 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(0), mapconsapp(z2, permute(revapp(1 + z0 + z1, 1 + z24 + z34)), select(z24, 1 + z2 + (1 + z0 + z1), z34))) + SELECT(z2, 1 + z0 + z1, 1 + z24 + z34) :|: z = z0, z1 >= 0, z'' = 1 + z2 + (1 + z24 + z34), z' = z1, z0 >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(0), 0) + SELECT(z2, 1 + z0 + z1, z3) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z0 + 0, z3) :|: z = z0, z0 >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(1 + z2 + 0), mapconsapp(z2, permute(revapp(1 + z0 + 0, 0)), 0)) + SELECT(z2, 1 + z0 + 0, 0) :|: z = z0, z'' = 1 + z2 + 0, z0 >= 0, z2 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(revapp(1 + z0 + 0, 1 + z23 + z33)), select(z23, 1 + z2 + (1 + z0 + 0), z33))) + SELECT(z2, 1 + z0 + 0, 1 + z23 + z33) :|: z = z0, z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z0 >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(revapp(z1, 1 + z2 + z3)), select(z2, 1 + z0 + z1, z3)) + PERMUTE(revapp(z1, 1 + z2 + z3)) + REVAPP(z1, 1 + z2 + z3) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(revapp(z14, 1 + z04 + 0)), 0) + PERMUTE(revapp(z14, 1 + z04 + 0)) + REVAPP(1 + z04 + z14, 0) :|: z'' = 0, z04 >= 0, z = z0, z' = 1 + z04 + z14, z0 >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(revapp(z14, 1 + z04 + 0)), 0) + PERMUTE(0) + REVAPP(1 + z04 + z14, 0) :|: z'' = 0, z04 >= 0, z = z0, z' = 1 + z04 + z14, z0 >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(0), 0) + PERMUTE(revapp(z15, 1 + z05 + 0)) + REVAPP(1 + z05 + z15, 0) :|: z'' = 0, z = z0, z15 >= 0, z0 >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(0), 0) + PERMUTE(0) + REVAPP(z1, 0) :|: z'' = 0, z = z0, z1 >= 0, z' = z1, z0 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(0), 0) + PERMUTE(0) + REVAPP(0, 0) :|: z'' = 0, z = z0, z0 >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> z1 :|: z = z0, z1 >= 0, z0 >= 0, z' = 0, z'' = z1 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z0 + z1) + mapconsapp(z0, z2, z3) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z'' = z3, z2 >= 0, z3 >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> z0 :|: z0 >= 0, z = 0, z' = z0 revapp(z, z') -{ 0 }-> revapp(z1, 1 + z0 + z2) :|: z1 >= 0, z' = z2, z0 >= 0, z = 1 + z0 + z1, z2 >= 0 revapp(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(revapp(z16, 1 + z06 + (1 + z2 + z3))), 0) :|: z = z0, z06 >= 0, z0 >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(revapp(z16, 1 + z06 + (1 + z2 + 0))), mapconsapp(z2, permute(revapp(1 + z0 + (1 + z06 + z16), 0)), 0)) :|: z = z0, z'' = 1 + z2 + 0, z06 >= 0, z0 >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(revapp(z16, 1 + z06 + (1 + z2 + (1 + z25 + z35)))), mapconsapp(z2, permute(revapp(1 + z0 + (1 + z06 + z16), 1 + z25 + z35)), select(z25, 1 + z2 + (1 + z0 + (1 + z06 + z16)), z35))) :|: z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z = z0, z35 >= 0, z06 >= 0, z0 >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(revapp(z17, 1 + z07 + 0)), 0) :|: z'' = 0, z = z0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z0 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(0), mapconsapp(z2, permute(revapp(1 + z0 + z1, 0)), 0)) :|: z = z0, z1 >= 0, z'' = 1 + z2 + 0, z' = z1, z0 >= 0, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(0), mapconsapp(z2, permute(revapp(1 + z0 + z1, 1 + z27 + z37)), select(z27, 1 + z2 + (1 + z0 + z1), z37))) :|: z = z0, z1 >= 0, z27 >= 0, z37 >= 0, z' = z1, z0 >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(0), 0) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(0), 0) :|: z'' = 0, z = z0, z0 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(0), 0) :|: z'' = 0, z = z0, z1 >= 0, z' = z1, z0 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(1 + z2 + z3), 0) :|: z = z0, z0 >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(1 + z2 + 0), mapconsapp(z2, permute(revapp(1 + z0 + 0, 0)), 0)) :|: z = z0, z'' = 1 + z2 + 0, z0 >= 0, z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(revapp(1 + z0 + 0, 1 + z26 + z36)), select(z26, 1 + z2 + (1 + z0 + 0), z36))) :|: z = z0, z26 >= 0, z36 >= 0, z0 >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 ---------------------------------------- (71) SimplificationProof (BOTH BOUNDS(ID, ID)) Simplified the RNTS by moving equalities from the constraints into the right-hand sides. ---------------------------------------- (72) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 }-> 1 + REVAPP(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + z2 + z3))), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + z2 + (1 + z22 + z32)))), mapconsapp(z2, permute(revapp(1 + z + (1 + z03 + z13), 1 + z22 + z32)), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + z03 + z13), 0)), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(revapp(1 + z + z', 1 + z24 + z34)), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(revapp(1 + z + z', 0)), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(revapp(1 + z + 0, 1 + z23 + z33)), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z', 1 + z2 + z3)), select(z2, 1 + z + z', z3)) + PERMUTE(revapp(z', 1 + z2 + z3)) + REVAPP(z', 1 + z2 + z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z14, 1 + z04 + 0)), 0) + PERMUTE(revapp(z14, 1 + z04 + 0)) + REVAPP(1 + z04 + z14, 0) :|: z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z14, 1 + z04 + 0)), 0) + PERMUTE(0) + REVAPP(1 + z04 + z14, 0) :|: z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(revapp(z15, 1 + z05 + 0)) + REVAPP(1 + z05 + z15, 0) :|: z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(z', 0) :|: z'' = 0, z' >= 0, z >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(0, 0) :|: z'' = 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + mapconsapp(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> revapp(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + z2 + z3))), 0) :|: z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + z2 + (1 + z25 + z35)))), mapconsapp(z2, permute(revapp(1 + z + (1 + z06 + z16), 1 + z25 + z35)), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + z06 + z16), 0)), 0)) :|: z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z17, 1 + z07 + 0)), 0) :|: z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(revapp(1 + z + z', 1 + z27 + z37)), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(revapp(1 + z + z', 0)), 0)) :|: z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(revapp(1 + z + 0, 1 + z26 + z36)), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) :|: z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 ---------------------------------------- (73) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID)) Found the following analysis order by SCC decomposition: { revapp } { REVAPP } { mapconsapp } { MAPCONSAPP } { permute, select } { PERMUTE, SELECT } ---------------------------------------- (74) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 }-> 1 + REVAPP(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + z2 + z3))), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + z2 + (1 + z22 + z32)))), mapconsapp(z2, permute(revapp(1 + z + (1 + z03 + z13), 1 + z22 + z32)), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + z03 + z13), 0)), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(revapp(1 + z + z', 1 + z24 + z34)), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(revapp(1 + z + z', 0)), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(revapp(1 + z + 0, 1 + z23 + z33)), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z', 1 + z2 + z3)), select(z2, 1 + z + z', z3)) + PERMUTE(revapp(z', 1 + z2 + z3)) + REVAPP(z', 1 + z2 + z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z14, 1 + z04 + 0)), 0) + PERMUTE(revapp(z14, 1 + z04 + 0)) + REVAPP(1 + z04 + z14, 0) :|: z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z14, 1 + z04 + 0)), 0) + PERMUTE(0) + REVAPP(1 + z04 + z14, 0) :|: z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(revapp(z15, 1 + z05 + 0)) + REVAPP(1 + z05 + z15, 0) :|: z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(z', 0) :|: z'' = 0, z' >= 0, z >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(0, 0) :|: z'' = 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + mapconsapp(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> revapp(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + z2 + z3))), 0) :|: z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + z2 + (1 + z25 + z35)))), mapconsapp(z2, permute(revapp(1 + z + (1 + z06 + z16), 1 + z25 + z35)), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + z06 + z16), 0)), 0)) :|: z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z17, 1 + z07 + 0)), 0) :|: z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(revapp(1 + z + z', 1 + z27 + z37)), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(revapp(1 + z + z', 0)), 0)) :|: z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(revapp(1 + z + 0, 1 + z26 + z36)), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) :|: z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {revapp}, {REVAPP}, {mapconsapp}, {MAPCONSAPP}, {permute,select}, {PERMUTE,SELECT} ---------------------------------------- (75) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (76) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 }-> 1 + REVAPP(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + z2 + z3))), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + z2 + (1 + z22 + z32)))), mapconsapp(z2, permute(revapp(1 + z + (1 + z03 + z13), 1 + z22 + z32)), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + z03 + z13), 0)), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(revapp(1 + z + z', 1 + z24 + z34)), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(revapp(1 + z + z', 0)), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(revapp(1 + z + 0, 1 + z23 + z33)), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z', 1 + z2 + z3)), select(z2, 1 + z + z', z3)) + PERMUTE(revapp(z', 1 + z2 + z3)) + REVAPP(z', 1 + z2 + z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z14, 1 + z04 + 0)), 0) + PERMUTE(revapp(z14, 1 + z04 + 0)) + REVAPP(1 + z04 + z14, 0) :|: z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z14, 1 + z04 + 0)), 0) + PERMUTE(0) + REVAPP(1 + z04 + z14, 0) :|: z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(revapp(z15, 1 + z05 + 0)) + REVAPP(1 + z05 + z15, 0) :|: z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(z', 0) :|: z'' = 0, z' >= 0, z >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(0, 0) :|: z'' = 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + mapconsapp(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> revapp(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + z2 + z3))), 0) :|: z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + z2 + (1 + z25 + z35)))), mapconsapp(z2, permute(revapp(1 + z + (1 + z06 + z16), 1 + z25 + z35)), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + z06 + z16), 0)), 0)) :|: z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z17, 1 + z07 + 0)), 0) :|: z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(revapp(1 + z + z', 1 + z27 + z37)), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(revapp(1 + z + z', 0)), 0)) :|: z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(revapp(1 + z + 0, 1 + z26 + z36)), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) :|: z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {revapp}, {REVAPP}, {mapconsapp}, {MAPCONSAPP}, {permute,select}, {PERMUTE,SELECT} ---------------------------------------- (77) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: revapp after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z + z' ---------------------------------------- (78) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 }-> 1 + REVAPP(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + z2 + z3))), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + z2 + (1 + z22 + z32)))), mapconsapp(z2, permute(revapp(1 + z + (1 + z03 + z13), 1 + z22 + z32)), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + z03 + z13), 0)), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(revapp(1 + z + z', 1 + z24 + z34)), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(revapp(1 + z + z', 0)), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(revapp(1 + z + 0, 1 + z23 + z33)), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z', 1 + z2 + z3)), select(z2, 1 + z + z', z3)) + PERMUTE(revapp(z', 1 + z2 + z3)) + REVAPP(z', 1 + z2 + z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z14, 1 + z04 + 0)), 0) + PERMUTE(revapp(z14, 1 + z04 + 0)) + REVAPP(1 + z04 + z14, 0) :|: z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z14, 1 + z04 + 0)), 0) + PERMUTE(0) + REVAPP(1 + z04 + z14, 0) :|: z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(revapp(z15, 1 + z05 + 0)) + REVAPP(1 + z05 + z15, 0) :|: z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(z', 0) :|: z'' = 0, z' >= 0, z >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(0, 0) :|: z'' = 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + mapconsapp(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> revapp(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + z2 + z3))), 0) :|: z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + z2 + (1 + z25 + z35)))), mapconsapp(z2, permute(revapp(1 + z + (1 + z06 + z16), 1 + z25 + z35)), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + z06 + z16), 0)), 0)) :|: z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z17, 1 + z07 + 0)), 0) :|: z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(revapp(1 + z + z', 1 + z27 + z37)), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(revapp(1 + z + z', 0)), 0)) :|: z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(revapp(1 + z + 0, 1 + z26 + z36)), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) :|: z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {revapp}, {REVAPP}, {mapconsapp}, {MAPCONSAPP}, {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: ?, size: O(n^1) [z + z'] ---------------------------------------- (79) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: revapp after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 0 ---------------------------------------- (80) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 }-> 1 + REVAPP(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + z2 + z3))), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + z2 + (1 + z22 + z32)))), mapconsapp(z2, permute(revapp(1 + z + (1 + z03 + z13), 1 + z22 + z32)), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z13, 1 + z03 + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + z03 + z13), 0)), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(revapp(1 + z + z', 1 + z24 + z34)), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(revapp(1 + z + z', 0)), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(revapp(1 + z + 0, 1 + z23 + z33)), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z', 1 + z2 + z3)), select(z2, 1 + z + z', z3)) + PERMUTE(revapp(z', 1 + z2 + z3)) + REVAPP(z', 1 + z2 + z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z14, 1 + z04 + 0)), 0) + PERMUTE(revapp(z14, 1 + z04 + 0)) + REVAPP(1 + z04 + z14, 0) :|: z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(revapp(z14, 1 + z04 + 0)), 0) + PERMUTE(0) + REVAPP(1 + z04 + z14, 0) :|: z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(revapp(z15, 1 + z05 + 0)) + REVAPP(1 + z05 + z15, 0) :|: z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(z', 0) :|: z'' = 0, z' >= 0, z >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(0, 0) :|: z'' = 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + mapconsapp(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> revapp(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + z2 + z3))), 0) :|: z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + z2 + (1 + z25 + z35)))), mapconsapp(z2, permute(revapp(1 + z + (1 + z06 + z16), 1 + z25 + z35)), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z16, 1 + z06 + (1 + (z'' - 1) + 0))), mapconsapp(z'' - 1, permute(revapp(1 + z + (1 + z06 + z16), 0)), 0)) :|: z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(revapp(z17, 1 + z07 + 0)), 0) :|: z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(revapp(1 + z + z', 1 + z27 + z37)), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(revapp(1 + z + z', 0)), 0)) :|: z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(revapp(1 + z + 0, 1 + z26 + z36)), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(revapp(1 + z + 0, 0)), 0)) :|: z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {REVAPP}, {mapconsapp}, {MAPCONSAPP}, {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] ---------------------------------------- (81) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (82) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 }-> 1 + REVAPP(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s''), mapconsapp(z2, permute(s1), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s2), mapconsapp(z'' - 1, permute(s3), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s4), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(s7), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(s8), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(s5), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s6), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s), select(z2, 1 + z + z', z3)) + PERMUTE(s') + REVAPP(z', 1 + z2 + z3) :|: s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s11), 0) + PERMUTE(0) + REVAPP(1 + z04 + z14, 0) :|: s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s9), 0) + PERMUTE(s10) + REVAPP(1 + z04 + z14, 0) :|: s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(s12) + REVAPP(1 + z05 + z15, 0) :|: s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(z', 0) :|: z'' = 0, z' >= 0, z >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(0, 0) :|: z'' = 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + mapconsapp(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s14), mapconsapp(z2, permute(s15), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s16), mapconsapp(z'' - 1, permute(s17), 0)) :|: s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s18), 0) :|: s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s23), 0) :|: s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(s21), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(s22), 0)) :|: s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(s19), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s20), 0)) :|: s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {REVAPP}, {mapconsapp}, {MAPCONSAPP}, {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] ---------------------------------------- (83) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: REVAPP after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 0 ---------------------------------------- (84) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 }-> 1 + REVAPP(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s''), mapconsapp(z2, permute(s1), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s2), mapconsapp(z'' - 1, permute(s3), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s4), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(s7), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(s8), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(s5), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s6), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s), select(z2, 1 + z + z', z3)) + PERMUTE(s') + REVAPP(z', 1 + z2 + z3) :|: s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s11), 0) + PERMUTE(0) + REVAPP(1 + z04 + z14, 0) :|: s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s9), 0) + PERMUTE(s10) + REVAPP(1 + z04 + z14, 0) :|: s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(s12) + REVAPP(1 + z05 + z15, 0) :|: s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(z', 0) :|: z'' = 0, z' >= 0, z >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(0, 0) :|: z'' = 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + mapconsapp(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s14), mapconsapp(z2, permute(s15), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s16), mapconsapp(z'' - 1, permute(s17), 0)) :|: s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s18), 0) :|: s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s23), 0) :|: s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(s21), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(s22), 0)) :|: s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(s19), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s20), 0)) :|: s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {REVAPP}, {mapconsapp}, {MAPCONSAPP}, {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: ?, size: O(1) [0] ---------------------------------------- (85) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: REVAPP after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z ---------------------------------------- (86) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 }-> 1 + REVAPP(z1, 1 + z0 + z') :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s''), mapconsapp(z2, permute(s1), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s2), mapconsapp(z'' - 1, permute(s3), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s4), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(s7), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(s8), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(s5), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s6), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s), select(z2, 1 + z + z', z3)) + PERMUTE(s') + REVAPP(z', 1 + z2 + z3) :|: s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s11), 0) + PERMUTE(0) + REVAPP(1 + z04 + z14, 0) :|: s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s9), 0) + PERMUTE(s10) + REVAPP(1 + z04 + z14, 0) :|: s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(s12) + REVAPP(1 + z05 + z15, 0) :|: s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(z', 0) :|: z'' = 0, z' >= 0, z >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + REVAPP(0, 0) :|: z'' = 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + mapconsapp(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s14), mapconsapp(z2, permute(s15), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s16), mapconsapp(z'' - 1, permute(s17), 0)) :|: s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s18), 0) :|: s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s23), 0) :|: s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(s21), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(s22), 0)) :|: s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(s19), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s20), 0)) :|: s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {mapconsapp}, {MAPCONSAPP}, {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] ---------------------------------------- (87) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (88) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 + z1 }-> 1 + s30 :|: s30 >= 0, s30 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s''), mapconsapp(z2, permute(s1), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s2), mapconsapp(z'' - 1, permute(s3), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s4), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(s7), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(s8), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(s5), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s6), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(s), select(z2, 1 + z + z', z3)) + PERMUTE(s') + s24 :|: s24 >= 0, s24 <= 0, s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s11), 0) + PERMUTE(0) + s26 :|: s26 >= 0, s26 <= 0, s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s9), 0) + PERMUTE(s10) + s25 :|: s25 >= 0, s25 <= 0, s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z05 + z15 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(s12) + s28 :|: s28 >= 0, s28 <= 0, s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s27 :|: s27 >= 0, s27 <= 0, z'' = 0, z >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s29 :|: s29 >= 0, s29 <= 0, z'' = 0, z' >= 0, z >= 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + mapconsapp(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s14), mapconsapp(z2, permute(s15), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s16), mapconsapp(z'' - 1, permute(s17), 0)) :|: s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s18), 0) :|: s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s23), 0) :|: s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(s21), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(s22), 0)) :|: s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(s19), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s20), 0)) :|: s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {mapconsapp}, {MAPCONSAPP}, {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] ---------------------------------------- (89) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: mapconsapp after applying outer abstraction to obtain an ITS, resulting in: O(n^2) with polynomial bound: z*z' + z' + z'^2 + z'' ---------------------------------------- (90) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 + z1 }-> 1 + s30 :|: s30 >= 0, s30 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s''), mapconsapp(z2, permute(s1), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s2), mapconsapp(z'' - 1, permute(s3), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s4), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(s7), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(s8), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(s5), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s6), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(s), select(z2, 1 + z + z', z3)) + PERMUTE(s') + s24 :|: s24 >= 0, s24 <= 0, s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s11), 0) + PERMUTE(0) + s26 :|: s26 >= 0, s26 <= 0, s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s9), 0) + PERMUTE(s10) + s25 :|: s25 >= 0, s25 <= 0, s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z05 + z15 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(s12) + s28 :|: s28 >= 0, s28 <= 0, s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s27 :|: s27 >= 0, s27 <= 0, z'' = 0, z >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s29 :|: s29 >= 0, s29 <= 0, z'' = 0, z' >= 0, z >= 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + mapconsapp(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s14), mapconsapp(z2, permute(s15), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s16), mapconsapp(z'' - 1, permute(s17), 0)) :|: s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s18), 0) :|: s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s23), 0) :|: s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(s21), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(s22), 0)) :|: s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(s19), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s20), 0)) :|: s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {mapconsapp}, {MAPCONSAPP}, {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] mapconsapp: runtime: ?, size: O(n^2) [z*z' + z' + z'^2 + z''] ---------------------------------------- (91) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: mapconsapp after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 0 ---------------------------------------- (92) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 + z1 }-> 1 + s30 :|: s30 >= 0, s30 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s''), mapconsapp(z2, permute(s1), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s2), mapconsapp(z'' - 1, permute(s3), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s4), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(s7), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(s8), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(s5), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s6), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(s), select(z2, 1 + z + z', z3)) + PERMUTE(s') + s24 :|: s24 >= 0, s24 <= 0, s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s11), 0) + PERMUTE(0) + s26 :|: s26 >= 0, s26 <= 0, s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s9), 0) + PERMUTE(s10) + s25 :|: s25 >= 0, s25 <= 0, s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z05 + z15 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(s12) + s28 :|: s28 >= 0, s28 <= 0, s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s27 :|: s27 >= 0, s27 <= 0, z'' = 0, z >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s29 :|: s29 >= 0, s29 <= 0, z'' = 0, z' >= 0, z >= 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + mapconsapp(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s14), mapconsapp(z2, permute(s15), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s16), mapconsapp(z'' - 1, permute(s17), 0)) :|: s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s18), 0) :|: s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s23), 0) :|: s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(s21), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(s22), 0)) :|: s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(s19), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s20), 0)) :|: s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {MAPCONSAPP}, {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] mapconsapp: runtime: O(1) [0], size: O(n^2) [z*z' + z' + z'^2 + z''] ---------------------------------------- (93) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (94) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 + z1 }-> 1 + s30 :|: s30 >= 0, s30 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s''), mapconsapp(z2, permute(s1), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s2), mapconsapp(z'' - 1, permute(s3), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s4), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(s7), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(s8), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(s5), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s6), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(s), select(z2, 1 + z + z', z3)) + PERMUTE(s') + s24 :|: s24 >= 0, s24 <= 0, s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s11), 0) + PERMUTE(0) + s26 :|: s26 >= 0, s26 <= 0, s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s9), 0) + PERMUTE(s10) + s25 :|: s25 >= 0, s25 <= 0, s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z05 + z15 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(s12) + s28 :|: s28 >= 0, s28 <= 0, s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s27 :|: s27 >= 0, s27 <= 0, z'' = 0, z >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s29 :|: s29 >= 0, s29 <= 0, z'' = 0, z' >= 0, z >= 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + s31 :|: s31 >= 0, s31 <= z2 * z + z2 * z2 + z2 + z'', z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s14), mapconsapp(z2, permute(s15), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s16), mapconsapp(z'' - 1, permute(s17), 0)) :|: s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s18), 0) :|: s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s23), 0) :|: s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(s21), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(s22), 0)) :|: s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(s19), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s20), 0)) :|: s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {MAPCONSAPP}, {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] mapconsapp: runtime: O(1) [0], size: O(n^2) [z*z' + z' + z'^2 + z''] ---------------------------------------- (95) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: MAPCONSAPP after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 0 ---------------------------------------- (96) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 + z1 }-> 1 + s30 :|: s30 >= 0, s30 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s''), mapconsapp(z2, permute(s1), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s2), mapconsapp(z'' - 1, permute(s3), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s4), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(s7), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(s8), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(s5), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s6), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(s), select(z2, 1 + z + z', z3)) + PERMUTE(s') + s24 :|: s24 >= 0, s24 <= 0, s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s11), 0) + PERMUTE(0) + s26 :|: s26 >= 0, s26 <= 0, s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s9), 0) + PERMUTE(s10) + s25 :|: s25 >= 0, s25 <= 0, s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z05 + z15 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(s12) + s28 :|: s28 >= 0, s28 <= 0, s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s27 :|: s27 >= 0, s27 <= 0, z'' = 0, z >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s29 :|: s29 >= 0, s29 <= 0, z'' = 0, z' >= 0, z >= 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + s31 :|: s31 >= 0, s31 <= z2 * z + z2 * z2 + z2 + z'', z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s14), mapconsapp(z2, permute(s15), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s16), mapconsapp(z'' - 1, permute(s17), 0)) :|: s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s18), 0) :|: s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s23), 0) :|: s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(s21), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(s22), 0)) :|: s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(s19), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s20), 0)) :|: s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {MAPCONSAPP}, {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] mapconsapp: runtime: O(1) [0], size: O(n^2) [z*z' + z' + z'^2 + z''] MAPCONSAPP: runtime: ?, size: O(1) [0] ---------------------------------------- (97) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: MAPCONSAPP after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z' ---------------------------------------- (98) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, z2, z'') :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 + z1 }-> 1 + s30 :|: s30 >= 0, s30 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s''), mapconsapp(z2, permute(s1), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s2), mapconsapp(z'' - 1, permute(s3), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s4), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(s7), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(s8), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(s5), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s6), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(s), select(z2, 1 + z + z', z3)) + PERMUTE(s') + s24 :|: s24 >= 0, s24 <= 0, s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s11), 0) + PERMUTE(0) + s26 :|: s26 >= 0, s26 <= 0, s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s9), 0) + PERMUTE(s10) + s25 :|: s25 >= 0, s25 <= 0, s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z05 + z15 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(s12) + s28 :|: s28 >= 0, s28 <= 0, s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s27 :|: s27 >= 0, s27 <= 0, z'' = 0, z >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s29 :|: s29 >= 0, s29 <= 0, z'' = 0, z' >= 0, z >= 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + s31 :|: s31 >= 0, s31 <= z2 * z + z2 * z2 + z2 + z'', z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s14), mapconsapp(z2, permute(s15), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s16), mapconsapp(z'' - 1, permute(s17), 0)) :|: s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s18), 0) :|: s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s23), 0) :|: s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(s21), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(s22), 0)) :|: s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(s19), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s20), 0)) :|: s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] mapconsapp: runtime: O(1) [0], size: O(n^2) [z*z' + z' + z'^2 + z''] MAPCONSAPP: runtime: O(n^1) [z'], size: O(1) [0] ---------------------------------------- (99) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (100) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 + z2 }-> 1 + s32 :|: s32 >= 0, s32 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 + z1 }-> 1 + s30 :|: s30 >= 0, s30 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s''), mapconsapp(z2, permute(s1), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s2), mapconsapp(z'' - 1, permute(s3), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s4), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(s7), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(s8), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(s5), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s6), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(s), select(z2, 1 + z + z', z3)) + PERMUTE(s') + s24 :|: s24 >= 0, s24 <= 0, s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s11), 0) + PERMUTE(0) + s26 :|: s26 >= 0, s26 <= 0, s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s9), 0) + PERMUTE(s10) + s25 :|: s25 >= 0, s25 <= 0, s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z05 + z15 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(s12) + s28 :|: s28 >= 0, s28 <= 0, s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s27 :|: s27 >= 0, s27 <= 0, z'' = 0, z >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s29 :|: s29 >= 0, s29 <= 0, z'' = 0, z' >= 0, z >= 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + s31 :|: s31 >= 0, s31 <= z2 * z + z2 * z2 + z2 + z'', z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s14), mapconsapp(z2, permute(s15), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s16), mapconsapp(z'' - 1, permute(s17), 0)) :|: s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s18), 0) :|: s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s23), 0) :|: s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(s21), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(s22), 0)) :|: s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(s19), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s20), 0)) :|: s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] mapconsapp: runtime: O(1) [0], size: O(n^2) [z*z' + z' + z'^2 + z''] MAPCONSAPP: runtime: O(n^1) [z'], size: O(1) [0] ---------------------------------------- (101) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: select after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (102) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 + z2 }-> 1 + s32 :|: s32 >= 0, s32 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 + z1 }-> 1 + s30 :|: s30 >= 0, s30 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s''), mapconsapp(z2, permute(s1), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s2), mapconsapp(z'' - 1, permute(s3), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s4), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(s7), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(s8), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(s5), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s6), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(s), select(z2, 1 + z + z', z3)) + PERMUTE(s') + s24 :|: s24 >= 0, s24 <= 0, s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s11), 0) + PERMUTE(0) + s26 :|: s26 >= 0, s26 <= 0, s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s9), 0) + PERMUTE(s10) + s25 :|: s25 >= 0, s25 <= 0, s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z05 + z15 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(s12) + s28 :|: s28 >= 0, s28 <= 0, s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s27 :|: s27 >= 0, s27 <= 0, z'' = 0, z >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s29 :|: s29 >= 0, s29 <= 0, z'' = 0, z' >= 0, z >= 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + s31 :|: s31 >= 0, s31 <= z2 * z + z2 * z2 + z2 + z'', z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s14), mapconsapp(z2, permute(s15), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s16), mapconsapp(z'' - 1, permute(s17), 0)) :|: s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s18), 0) :|: s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s23), 0) :|: s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(s21), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(s22), 0)) :|: s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(s19), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s20), 0)) :|: s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {permute,select}, {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] mapconsapp: runtime: O(1) [0], size: O(n^2) [z*z' + z' + z'^2 + z''] MAPCONSAPP: runtime: O(n^1) [z'], size: O(1) [0] permute: runtime: ?, size: INF select: runtime: ?, size: INF ---------------------------------------- (103) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using KoAT for: permute after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 0 Computed RUNTIME bound using CoFloCo for: select after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 0 ---------------------------------------- (104) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 + z2 }-> 1 + s32 :|: s32 >= 0, s32 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 + z1 }-> 1 + s30 :|: s30 >= 0, s30 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s''), mapconsapp(z2, permute(s1), select(z22, 1 + z2 + (1 + z + (1 + z03 + z13)), z32))) + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s2), mapconsapp(z'' - 1, permute(s3), 0)) + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(s4), 0) + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z2, permute(s7), select(z24, 1 + z2 + (1 + z + z'), z34))) + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), mapconsapp(z'' - 1, permute(s8), 0)) + SELECT(z'' - 1, 1 + z + z', 0) :|: s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + SELECT(z2, 1 + z + z', z3) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + z3), 0) + SELECT(z2, 1 + z + 0, z3) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + z2 + (1 + z23 + z33)), mapconsapp(z2, permute(s5), select(z23, 1 + z2 + (1 + z + 0), z33))) + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s6), 0)) + SELECT(z'' - 1, 1 + z + 0, 0) :|: s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(s), select(z2, 1 + z + z', z3)) + PERMUTE(s') + s24 :|: s24 >= 0, s24 <= 0, s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s11), 0) + PERMUTE(0) + s26 :|: s26 >= 0, s26 <= 0, s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z04 + z14 }-> 1 + MAPCONSAPP(z, permute(s9), 0) + PERMUTE(s10) + s25 :|: s25 >= 0, s25 <= 0, s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + z05 + z15 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(s12) + s28 :|: s28 >= 0, s28 <= 0, s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s27 :|: s27 >= 0, s27 <= 0, z'' = 0, z >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + z' }-> 1 + MAPCONSAPP(z, permute(0), 0) + PERMUTE(0) + s29 :|: s29 >= 0, s29 <= 0, z'' = 0, z' >= 0, z >= 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + s31 :|: s31 >= 0, s31 <= z2 * z + z2 * z2 + z2 + z'', z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s14), mapconsapp(z2, permute(s15), select(z25, 1 + z2 + (1 + z + (1 + z06 + z16)), z35))) :|: s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s16), mapconsapp(z'' - 1, permute(s17), 0)) :|: s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s18), 0) :|: s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(s23), 0) :|: s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z2, permute(s21), select(z27, 1 + z2 + (1 + z + z'), z37))) :|: s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), mapconsapp(z'' - 1, permute(s22), 0)) :|: s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(0), 0) :|: z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + z3), 0) :|: z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + z2 + (1 + z26 + z36)), mapconsapp(z2, permute(s19), select(z26, 1 + z2 + (1 + z + 0), z36))) :|: s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> mapconsapp(z, permute(1 + (z'' - 1) + 0), mapconsapp(z'' - 1, permute(s20), 0)) :|: s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] mapconsapp: runtime: O(1) [0], size: O(n^2) [z*z' + z' + z'^2 + z''] MAPCONSAPP: runtime: O(n^1) [z'], size: O(1) [0] permute: runtime: O(1) [0], size: INF select: runtime: O(1) [0], size: INF ---------------------------------------- (105) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (106) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 + z2 }-> 1 + s32 :|: s32 >= 0, s32 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 + z1 }-> 1 + s30 :|: s30 >= 0, s30 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 + s36 }-> 1 + s40 + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s36 >= 0, s36 <= inf'', s37 >= 0, s37 <= inf1, s38 >= 0, s38 <= inf2, s39 >= 0, s39 <= s37 * z2 + s37 * s37 + s37 + s38, s40 >= 0, s40 <= 0, s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 + s41 }-> 1 + s44 + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s41 >= 0, s41 <= inf3, s42 >= 0, s42 <= inf4, s43 >= 0, s43 <= s42 * (z'' - 1) + s42 * s42 + s42 + 0, s44 >= 0, s44 <= 0, s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 + s45 }-> 1 + s46 + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s45 >= 0, s45 <= inf5, s46 >= 0, s46 <= 0, s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 + s47 }-> 1 + s51 + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s47 >= 0, s47 <= inf6, s48 >= 0, s48 <= inf7, s49 >= 0, s49 <= inf8, s50 >= 0, s50 <= s48 * z2 + s48 * s48 + s48 + s49, s51 >= 0, s51 <= 0, s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + s52 }-> 1 + s55 + SELECT(z'' - 1, 1 + z + 0, 0) :|: s52 >= 0, s52 <= inf9, s53 >= 0, s53 <= inf10, s54 >= 0, s54 <= s53 * (z'' - 1) + s53 * s53 + s53 + 0, s55 >= 0, s55 <= 0, s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + s56 }-> 1 + s57 + SELECT(z2, 1 + z + 0, z3) :|: s56 >= 0, s56 <= inf11, s57 >= 0, s57 <= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + s58 }-> 1 + s62 + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s58 >= 0, s58 <= inf12, s59 >= 0, s59 <= inf13, s60 >= 0, s60 <= inf14, s61 >= 0, s61 <= s59 * z2 + s59 * s59 + s59 + s60, s62 >= 0, s62 <= 0, s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 + s63 }-> 1 + s66 + SELECT(z'' - 1, 1 + z + z', 0) :|: s63 >= 0, s63 <= inf15, s64 >= 0, s64 <= inf16, s65 >= 0, s65 <= s64 * (z'' - 1) + s64 * s64 + s64 + 0, s66 >= 0, s66 <= 0, s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 + s67 }-> 1 + s68 + SELECT(z2, 1 + z + z', z3) :|: s67 >= 0, s67 <= inf17, s68 >= 0, s68 <= 0, z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 + s33 + z' }-> 1 + s35 + PERMUTE(s') + s24 :|: s33 >= 0, s33 <= inf, s34 >= 0, s34 <= inf', s35 >= 0, s35 <= 0, s24 >= 0, s24 <= 0, s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 2 + s69 + z04 + z14 }-> 1 + s70 + PERMUTE(s10) + s25 :|: s69 >= 0, s69 <= inf18, s70 >= 0, s70 <= 0, s25 >= 0, s25 <= 0, s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + s71 + z04 + z14 }-> 1 + s72 + PERMUTE(0) + s26 :|: s71 >= 0, s71 <= inf19, s72 >= 0, s72 <= 0, s26 >= 0, s26 <= 0, s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 + s73 }-> 1 + s74 + PERMUTE(0) + s27 :|: s73 >= 0, s73 <= inf20, s74 >= 0, s74 <= 0, s27 >= 0, s27 <= 0, z'' = 0, z >= 0, z' = 0 SELECT(z, z', z'') -{ 2 + s75 + z05 + z15 }-> 1 + s76 + PERMUTE(s12) + s28 :|: s75 >= 0, s75 <= inf21, s76 >= 0, s76 <= 0, s28 >= 0, s28 <= 0, s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 + s77 + z' }-> 1 + s78 + PERMUTE(0) + s29 :|: s77 >= 0, s77 <= inf22, s78 >= 0, s78 <= 0, s29 >= 0, s29 <= 0, z'' = 0, z' >= 0, z >= 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + s31 :|: s31 >= 0, s31 <= z2 * z + z2 * z2 + z2 + z'', z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> s79 :|: s79 >= 0, s79 <= inf23, z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> s101 :|: s100 >= 0, s100 <= inf35, s101 >= 0, s101 <= s100 * z + s100 * s100 + s100 + 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> s106 :|: s102 >= 0, s102 <= inf36, s103 >= 0, s103 <= inf37, s104 >= 0, s104 <= inf38, s105 >= 0, s105 <= s103 * z2 + s103 * s103 + s103 + s104, s106 >= 0, s106 <= s102 * z + s102 * s102 + s102 + s105, s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> s110 :|: s107 >= 0, s107 <= inf39, s108 >= 0, s108 <= inf40, s109 >= 0, s109 <= s108 * (z'' - 1) + s108 * s108 + s108 + 0, s110 >= 0, s110 <= s107 * z + s107 * s107 + s107 + s109, s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> s112 :|: s111 >= 0, s111 <= inf41, s112 >= 0, s112 <= s111 * z + s111 * s111 + s111 + 0, z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> s114 :|: s113 >= 0, s113 <= inf42, s114 >= 0, s114 <= s113 * z + s113 * s113 + s113 + 0, s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> s116 :|: s115 >= 0, s115 <= inf43, s116 >= 0, s116 <= s115 * z + s115 * s115 + s115 + 0, z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> s118 :|: s117 >= 0, s117 <= inf44, s118 >= 0, s118 <= s117 * z + s117 * s117 + s117 + 0, z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> s84 :|: s80 >= 0, s80 <= inf24, s81 >= 0, s81 <= inf25, s82 >= 0, s82 <= inf26, s83 >= 0, s83 <= s81 * z2 + s81 * s81 + s81 + s82, s84 >= 0, s84 <= s80 * z + s80 * s80 + s80 + s83, s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> s88 :|: s85 >= 0, s85 <= inf27, s86 >= 0, s86 <= inf28, s87 >= 0, s87 <= s86 * (z'' - 1) + s86 * s86 + s86 + 0, s88 >= 0, s88 <= s85 * z + s85 * s85 + s85 + s87, s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> s90 :|: s89 >= 0, s89 <= inf29, s90 >= 0, s90 <= s89 * z + s89 * s89 + s89 + 0, s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> s95 :|: s91 >= 0, s91 <= inf30, s92 >= 0, s92 <= inf31, s93 >= 0, s93 <= inf32, s94 >= 0, s94 <= s92 * z2 + s92 * s92 + s92 + s93, s95 >= 0, s95 <= s91 * z + s91 * s91 + s91 + s94, s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> s99 :|: s96 >= 0, s96 <= inf33, s97 >= 0, s97 <= inf34, s98 >= 0, s98 <= s97 * (z'' - 1) + s97 * s97 + s97 + 0, s99 >= 0, s99 <= s96 * z + s96 * s96 + s96 + s98, s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] mapconsapp: runtime: O(1) [0], size: O(n^2) [z*z' + z' + z'^2 + z''] MAPCONSAPP: runtime: O(n^1) [z'], size: O(1) [0] permute: runtime: O(1) [0], size: INF select: runtime: O(1) [0], size: INF ---------------------------------------- (107) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: PERMUTE after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 0 Computed SIZE bound using CoFloCo for: SELECT after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 3 + z'' ---------------------------------------- (108) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 + z2 }-> 1 + s32 :|: s32 >= 0, s32 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 + z1 }-> 1 + s30 :|: s30 >= 0, s30 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 + s36 }-> 1 + s40 + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s36 >= 0, s36 <= inf'', s37 >= 0, s37 <= inf1, s38 >= 0, s38 <= inf2, s39 >= 0, s39 <= s37 * z2 + s37 * s37 + s37 + s38, s40 >= 0, s40 <= 0, s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 + s41 }-> 1 + s44 + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s41 >= 0, s41 <= inf3, s42 >= 0, s42 <= inf4, s43 >= 0, s43 <= s42 * (z'' - 1) + s42 * s42 + s42 + 0, s44 >= 0, s44 <= 0, s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 + s45 }-> 1 + s46 + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s45 >= 0, s45 <= inf5, s46 >= 0, s46 <= 0, s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 + s47 }-> 1 + s51 + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s47 >= 0, s47 <= inf6, s48 >= 0, s48 <= inf7, s49 >= 0, s49 <= inf8, s50 >= 0, s50 <= s48 * z2 + s48 * s48 + s48 + s49, s51 >= 0, s51 <= 0, s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + s52 }-> 1 + s55 + SELECT(z'' - 1, 1 + z + 0, 0) :|: s52 >= 0, s52 <= inf9, s53 >= 0, s53 <= inf10, s54 >= 0, s54 <= s53 * (z'' - 1) + s53 * s53 + s53 + 0, s55 >= 0, s55 <= 0, s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + s56 }-> 1 + s57 + SELECT(z2, 1 + z + 0, z3) :|: s56 >= 0, s56 <= inf11, s57 >= 0, s57 <= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + s58 }-> 1 + s62 + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s58 >= 0, s58 <= inf12, s59 >= 0, s59 <= inf13, s60 >= 0, s60 <= inf14, s61 >= 0, s61 <= s59 * z2 + s59 * s59 + s59 + s60, s62 >= 0, s62 <= 0, s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 + s63 }-> 1 + s66 + SELECT(z'' - 1, 1 + z + z', 0) :|: s63 >= 0, s63 <= inf15, s64 >= 0, s64 <= inf16, s65 >= 0, s65 <= s64 * (z'' - 1) + s64 * s64 + s64 + 0, s66 >= 0, s66 <= 0, s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 + s67 }-> 1 + s68 + SELECT(z2, 1 + z + z', z3) :|: s67 >= 0, s67 <= inf17, s68 >= 0, s68 <= 0, z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 + s33 + z' }-> 1 + s35 + PERMUTE(s') + s24 :|: s33 >= 0, s33 <= inf, s34 >= 0, s34 <= inf', s35 >= 0, s35 <= 0, s24 >= 0, s24 <= 0, s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 2 + s69 + z04 + z14 }-> 1 + s70 + PERMUTE(s10) + s25 :|: s69 >= 0, s69 <= inf18, s70 >= 0, s70 <= 0, s25 >= 0, s25 <= 0, s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + s71 + z04 + z14 }-> 1 + s72 + PERMUTE(0) + s26 :|: s71 >= 0, s71 <= inf19, s72 >= 0, s72 <= 0, s26 >= 0, s26 <= 0, s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 + s73 }-> 1 + s74 + PERMUTE(0) + s27 :|: s73 >= 0, s73 <= inf20, s74 >= 0, s74 <= 0, s27 >= 0, s27 <= 0, z'' = 0, z >= 0, z' = 0 SELECT(z, z', z'') -{ 2 + s75 + z05 + z15 }-> 1 + s76 + PERMUTE(s12) + s28 :|: s75 >= 0, s75 <= inf21, s76 >= 0, s76 <= 0, s28 >= 0, s28 <= 0, s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 + s77 + z' }-> 1 + s78 + PERMUTE(0) + s29 :|: s77 >= 0, s77 <= inf22, s78 >= 0, s78 <= 0, s29 >= 0, s29 <= 0, z'' = 0, z' >= 0, z >= 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + s31 :|: s31 >= 0, s31 <= z2 * z + z2 * z2 + z2 + z'', z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> s79 :|: s79 >= 0, s79 <= inf23, z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> s101 :|: s100 >= 0, s100 <= inf35, s101 >= 0, s101 <= s100 * z + s100 * s100 + s100 + 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> s106 :|: s102 >= 0, s102 <= inf36, s103 >= 0, s103 <= inf37, s104 >= 0, s104 <= inf38, s105 >= 0, s105 <= s103 * z2 + s103 * s103 + s103 + s104, s106 >= 0, s106 <= s102 * z + s102 * s102 + s102 + s105, s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> s110 :|: s107 >= 0, s107 <= inf39, s108 >= 0, s108 <= inf40, s109 >= 0, s109 <= s108 * (z'' - 1) + s108 * s108 + s108 + 0, s110 >= 0, s110 <= s107 * z + s107 * s107 + s107 + s109, s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> s112 :|: s111 >= 0, s111 <= inf41, s112 >= 0, s112 <= s111 * z + s111 * s111 + s111 + 0, z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> s114 :|: s113 >= 0, s113 <= inf42, s114 >= 0, s114 <= s113 * z + s113 * s113 + s113 + 0, s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> s116 :|: s115 >= 0, s115 <= inf43, s116 >= 0, s116 <= s115 * z + s115 * s115 + s115 + 0, z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> s118 :|: s117 >= 0, s117 <= inf44, s118 >= 0, s118 <= s117 * z + s117 * s117 + s117 + 0, z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> s84 :|: s80 >= 0, s80 <= inf24, s81 >= 0, s81 <= inf25, s82 >= 0, s82 <= inf26, s83 >= 0, s83 <= s81 * z2 + s81 * s81 + s81 + s82, s84 >= 0, s84 <= s80 * z + s80 * s80 + s80 + s83, s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> s88 :|: s85 >= 0, s85 <= inf27, s86 >= 0, s86 <= inf28, s87 >= 0, s87 <= s86 * (z'' - 1) + s86 * s86 + s86 + 0, s88 >= 0, s88 <= s85 * z + s85 * s85 + s85 + s87, s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> s90 :|: s89 >= 0, s89 <= inf29, s90 >= 0, s90 <= s89 * z + s89 * s89 + s89 + 0, s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> s95 :|: s91 >= 0, s91 <= inf30, s92 >= 0, s92 <= inf31, s93 >= 0, s93 <= inf32, s94 >= 0, s94 <= s92 * z2 + s92 * s92 + s92 + s93, s95 >= 0, s95 <= s91 * z + s91 * s91 + s91 + s94, s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> s99 :|: s96 >= 0, s96 <= inf33, s97 >= 0, s97 <= inf34, s98 >= 0, s98 <= s97 * (z'' - 1) + s97 * s97 + s97 + 0, s99 >= 0, s99 <= s96 * z + s96 * s96 + s96 + s98, s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] mapconsapp: runtime: O(1) [0], size: O(n^2) [z*z' + z' + z'^2 + z''] MAPCONSAPP: runtime: O(n^1) [z'], size: O(1) [0] permute: runtime: O(1) [0], size: INF select: runtime: O(1) [0], size: INF PERMUTE: runtime: ?, size: O(1) [0] SELECT: runtime: ?, size: O(n^1) [3 + z''] ---------------------------------------- (109) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: PERMUTE after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (110) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 1 + z2 }-> 1 + s32 :|: s32 >= 0, s32 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 1 + z1 }-> 1 + s30 :|: s30 >= 0, s30 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 SELECT(z, z', z'') -{ 1 + s36 }-> 1 + s40 + SELECT(z2, 1 + z + (1 + z03 + z13), 1 + z22 + z32) :|: s36 >= 0, s36 <= inf'', s37 >= 0, s37 <= inf1, s38 >= 0, s38 <= inf2, s39 >= 0, s39 <= s37 * z2 + s37 * s37 + s37 + s38, s40 >= 0, s40 <= 0, s'' >= 0, s'' <= z13 + (1 + z03 + (1 + z2 + (1 + z22 + z32))), s1 >= 0, s1 <= 1 + z + (1 + z03 + z13) + (1 + z22 + z32), z32 >= 0, z'' = 1 + z2 + (1 + z22 + z32), z >= 0, z' = 1 + z03 + z13, z03 >= 0, z22 >= 0, z13 >= 0, z2 >= 0 SELECT(z, z', z'') -{ 1 + s41 }-> 1 + s44 + SELECT(z'' - 1, 1 + z + (1 + z03 + z13), 0) :|: s41 >= 0, s41 <= inf3, s42 >= 0, s42 <= inf4, s43 >= 0, s43 <= s42 * (z'' - 1) + s42 * s42 + s42 + 0, s44 >= 0, s44 <= 0, s2 >= 0, s2 <= z13 + (1 + z03 + (1 + (z'' - 1) + 0)), s3 >= 0, s3 <= 1 + z + (1 + z03 + z13) + 0, z >= 0, z' = 1 + z03 + z13, z03 >= 0, z13 >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 + s45 }-> 1 + s46 + SELECT(z2, 1 + z + (1 + z03 + z13), z3) :|: s45 >= 0, s45 <= inf5, s46 >= 0, s46 <= 0, s4 >= 0, s4 <= z13 + (1 + z03 + (1 + z2 + z3)), z >= 0, z' = 1 + z03 + z13, z'' = 1 + z2 + z3, z03 >= 0, z13 >= 0, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 + s47 }-> 1 + s51 + SELECT(z2, 1 + z + 0, 1 + z23 + z33) :|: s47 >= 0, s47 <= inf6, s48 >= 0, s48 <= inf7, s49 >= 0, s49 <= inf8, s50 >= 0, s50 <= s48 * z2 + s48 * s48 + s48 + s49, s51 >= 0, s51 <= 0, s5 >= 0, s5 <= 1 + z + 0 + (1 + z23 + z33), z'' = 1 + z2 + (1 + z23 + z33), z23 >= 0, z >= 0, z2 >= 0, z33 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + s52 }-> 1 + s55 + SELECT(z'' - 1, 1 + z + 0, 0) :|: s52 >= 0, s52 <= inf9, s53 >= 0, s53 <= inf10, s54 >= 0, s54 <= s53 * (z'' - 1) + s53 * s53 + s53 + 0, s55 >= 0, s55 <= 0, s6 >= 0, s6 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + s56 }-> 1 + s57 + SELECT(z2, 1 + z + 0, z3) :|: s56 >= 0, s56 <= inf11, s57 >= 0, s57 <= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 SELECT(z, z', z'') -{ 1 + s58 }-> 1 + s62 + SELECT(z2, 1 + z + z', 1 + z24 + z34) :|: s58 >= 0, s58 <= inf12, s59 >= 0, s59 <= inf13, s60 >= 0, s60 <= inf14, s61 >= 0, s61 <= s59 * z2 + s59 * s59 + s59 + s60, s62 >= 0, s62 <= 0, s7 >= 0, s7 <= 1 + z + z' + (1 + z24 + z34), z' >= 0, z'' = 1 + z2 + (1 + z24 + z34), z >= 0, z24 >= 0, z2 >= 0, z34 >= 0 SELECT(z, z', z'') -{ 1 + s63 }-> 1 + s66 + SELECT(z'' - 1, 1 + z + z', 0) :|: s63 >= 0, s63 <= inf15, s64 >= 0, s64 <= inf16, s65 >= 0, s65 <= s64 * (z'' - 1) + s64 * s64 + s64 + 0, s66 >= 0, s66 <= 0, s8 >= 0, s8 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 SELECT(z, z', z'') -{ 1 + s67 }-> 1 + s68 + SELECT(z2, 1 + z + z', z3) :|: s67 >= 0, s67 <= inf17, s68 >= 0, s68 <= 0, z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 + s33 + z' }-> 1 + s35 + PERMUTE(s') + s24 :|: s33 >= 0, s33 <= inf, s34 >= 0, s34 <= inf', s35 >= 0, s35 <= 0, s24 >= 0, s24 <= 0, s >= 0, s <= z' + (1 + z2 + z3), s' >= 0, s' <= z' + (1 + z2 + z3), z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 2 + s69 + z04 + z14 }-> 1 + s70 + PERMUTE(s10) + s25 :|: s69 >= 0, s69 <= inf18, s70 >= 0, s70 <= 0, s25 >= 0, s25 <= 0, s9 >= 0, s9 <= z14 + (1 + z04 + 0), s10 >= 0, s10 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 2 + s71 + z04 + z14 }-> 1 + s72 + PERMUTE(0) + s26 :|: s71 >= 0, s71 <= inf19, s72 >= 0, s72 <= 0, s26 >= 0, s26 <= 0, s11 >= 0, s11 <= z14 + (1 + z04 + 0), z'' = 0, z04 >= 0, z' = 1 + z04 + z14, z >= 0, z14 >= 0 SELECT(z, z', z'') -{ 1 + s73 }-> 1 + s74 + PERMUTE(0) + s27 :|: s73 >= 0, s73 <= inf20, s74 >= 0, s74 <= 0, s27 >= 0, s27 <= 0, z'' = 0, z >= 0, z' = 0 SELECT(z, z', z'') -{ 2 + s75 + z05 + z15 }-> 1 + s76 + PERMUTE(s12) + s28 :|: s75 >= 0, s75 <= inf21, s76 >= 0, s76 <= 0, s28 >= 0, s28 <= 0, s12 >= 0, s12 <= z15 + (1 + z05 + 0), z'' = 0, z15 >= 0, z >= 0, z' = 1 + z05 + z15, z05 >= 0 SELECT(z, z', z'') -{ 1 + s77 + z' }-> 1 + s78 + PERMUTE(0) + s29 :|: s77 >= 0, s77 <= inf22, s78 >= 0, s78 <= 0, s29 >= 0, s29 <= 0, z'' = 0, z' >= 0, z >= 0 mapconsapp(z, z', z'') -{ 0 }-> z'' :|: z'' >= 0, z >= 0, z' = 0 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z + z1) + s31 :|: s31 >= 0, s31 <= z2 * z + z2 * z2 + z2 + z'', z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, z'' >= 0 permute(z) -{ 0 }-> s79 :|: s79 >= 0, s79 <= inf23, z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: z >= 0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> s13 :|: s13 >= 0, s13 <= z1 + (1 + z0 + z'), z1 >= 0, z0 >= 0, z = 1 + z0 + z1, z' >= 0 revapp(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0 revapp(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 select(z, z', z'') -{ 0 }-> s101 :|: s100 >= 0, s100 <= inf35, s101 >= 0, s101 <= s100 * z + s100 * s100 + s100 + 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> s106 :|: s102 >= 0, s102 <= inf36, s103 >= 0, s103 <= inf37, s104 >= 0, s104 <= inf38, s105 >= 0, s105 <= s103 * z2 + s103 * s103 + s103 + s104, s106 >= 0, s106 <= s102 * z + s102 * s102 + s102 + s105, s21 >= 0, s21 <= 1 + z + z' + (1 + z27 + z37), z' >= 0, z27 >= 0, z37 >= 0, z >= 0, z'' = 1 + z2 + (1 + z27 + z37), z2 >= 0 select(z, z', z'') -{ 0 }-> s110 :|: s107 >= 0, s107 <= inf39, s108 >= 0, s108 <= inf40, s109 >= 0, s109 <= s108 * (z'' - 1) + s108 * s108 + s108 + 0, s110 >= 0, s110 <= s107 * z + s107 * s107 + s107 + s109, s22 >= 0, s22 <= 1 + z + z' + 0, z' >= 0, z >= 0, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> s112 :|: s111 >= 0, s111 <= inf41, s112 >= 0, s112 <= s111 * z + s111 * s111 + s111 + 0, z' >= 0, z >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> s114 :|: s113 >= 0, s113 <= inf42, s114 >= 0, s114 <= s113 * z + s113 * s113 + s113 + 0, s23 >= 0, s23 <= z17 + (1 + z07 + 0), z'' = 0, z' = 1 + z07 + z17, z07 >= 0, z17 >= 0, z >= 0 select(z, z', z'') -{ 0 }-> s116 :|: s115 >= 0, s115 <= inf43, s116 >= 0, s116 <= s115 * z + s115 * s115 + s115 + 0, z'' = 0, z >= 0, z' = 0 select(z, z', z'') -{ 0 }-> s118 :|: s117 >= 0, s117 <= inf44, s118 >= 0, s118 <= s117 * z + s117 * s117 + s117 + 0, z'' = 0, z' >= 0, z >= 0 select(z, z', z'') -{ 0 }-> s84 :|: s80 >= 0, s80 <= inf24, s81 >= 0, s81 <= inf25, s82 >= 0, s82 <= inf26, s83 >= 0, s83 <= s81 * z2 + s81 * s81 + s81 + s82, s84 >= 0, s84 <= s80 * z + s80 * s80 + s80 + s83, s14 >= 0, s14 <= z16 + (1 + z06 + (1 + z2 + (1 + z25 + z35))), s15 >= 0, s15 <= 1 + z + (1 + z06 + z16) + (1 + z25 + z35), z25 >= 0, z'' = 1 + z2 + (1 + z25 + z35), z35 >= 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z2 >= 0 select(z, z', z'') -{ 0 }-> s88 :|: s85 >= 0, s85 <= inf27, s86 >= 0, s86 <= inf28, s87 >= 0, s87 <= s86 * (z'' - 1) + s86 * s86 + s86 + 0, s88 >= 0, s88 <= s85 * z + s85 * s85 + s85 + s87, s16 >= 0, s16 <= z16 + (1 + z06 + (1 + (z'' - 1) + 0)), s17 >= 0, s17 <= 1 + z + (1 + z06 + z16) + 0, z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' - 1 >= 0 select(z, z', z'') -{ 0 }-> s90 :|: s89 >= 0, s89 <= inf29, s90 >= 0, s90 <= s89 * z + s89 * s89 + s89 + 0, s18 >= 0, s18 <= z16 + (1 + z06 + (1 + z2 + z3)), z06 >= 0, z >= 0, z16 >= 0, z' = 1 + z06 + z16, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> s95 :|: s91 >= 0, s91 <= inf30, s92 >= 0, s92 <= inf31, s93 >= 0, s93 <= inf32, s94 >= 0, s94 <= s92 * z2 + s92 * s92 + s92 + s93, s95 >= 0, s95 <= s91 * z + s91 * s91 + s91 + s94, s19 >= 0, s19 <= 1 + z + 0 + (1 + z26 + z36), z26 >= 0, z36 >= 0, z >= 0, z'' = 1 + z2 + (1 + z26 + z36), z2 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> s99 :|: s96 >= 0, s96 <= inf33, s97 >= 0, s97 <= inf34, s98 >= 0, s98 <= s97 * (z'' - 1) + s97 * s97 + s97 + 0, s99 >= 0, s99 <= s96 * z + s96 * s96 + s96 + s98, s20 >= 0, s20 <= 1 + z + 0 + 0, z >= 0, z'' - 1 >= 0, z' = 0 select(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 Function symbols to be analyzed: {PERMUTE,SELECT} Previous analysis results are: revapp: runtime: O(1) [0], size: O(n^1) [z + z'] REVAPP: runtime: O(n^1) [z], size: O(1) [0] mapconsapp: runtime: O(1) [0], size: O(n^2) [z*z' + z' + z'^2 + z''] MAPCONSAPP: runtime: O(n^1) [z'], size: O(1) [0] permute: runtime: O(1) [0], size: INF select: runtime: O(1) [0], size: INF PERMUTE: runtime: INF, size: O(1) [0] SELECT: runtime: ?, size: O(n^1) [3 + z''] ---------------------------------------- (111) CompletionProof (UPPER BOUND(ID)) The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added: permute(v0) -> null_permute [0] revapp(v0, v1) -> null_revapp [0] select(v0, v1, v2) -> null_select [0] mapconsapp(v0, v1, v2) -> null_mapconsapp [0] SELECT(v0, v1, v2) -> null_SELECT [0] REVAPP(v0, v1) -> null_REVAPP [0] PERMUTE(v0) -> null_PERMUTE [0] MAPCONSAPP(v0, v1, v2) -> null_MAPCONSAPP [0] And the following fresh constants: null_permute, null_revapp, null_select, null_mapconsapp, null_SELECT, null_REVAPP, null_PERMUTE, null_MAPCONSAPP ---------------------------------------- (112) Obligation: Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) [1] SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) [1] SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) [1] REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) [1] PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) [1] MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) [1] permute(Cons(z0, z1)) -> select(z0, Nil, z1) [0] permute(Nil) -> Cons(Nil, Nil) [0] revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) [0] revapp(Nil, z0) -> z0 [0] select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) [0] select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) [0] mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) [0] mapconsapp(z0, Nil, z1) -> z1 [0] permute(v0) -> null_permute [0] revapp(v0, v1) -> null_revapp [0] select(v0, v1, v2) -> null_select [0] mapconsapp(v0, v1, v2) -> null_mapconsapp [0] SELECT(v0, v1, v2) -> null_SELECT [0] REVAPP(v0, v1) -> null_REVAPP [0] PERMUTE(v0) -> null_PERMUTE [0] MAPCONSAPP(v0, v1, v2) -> null_MAPCONSAPP [0] The TRS has the following type information: SELECT :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> c:c1:c2:null_SELECT Cons :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp c :: c7:null_MAPCONSAPP -> c5:null_PERMUTE -> c3:null_REVAPP -> c:c1:c2:null_SELECT MAPCONSAPP :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> c7:null_MAPCONSAPP permute :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp revapp :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp select :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp PERMUTE :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> c5:null_PERMUTE REVAPP :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> c3:null_REVAPP c1 :: c7:null_MAPCONSAPP -> c:c1:c2:null_SELECT -> c:c1:c2:null_SELECT Nil :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp c2 :: c7:null_MAPCONSAPP -> c5:null_PERMUTE -> c3:null_REVAPP -> c:c1:c2:null_SELECT c3 :: c3:null_REVAPP -> c3:null_REVAPP c5 :: c:c1:c2:null_SELECT -> c5:null_PERMUTE c7 :: c7:null_MAPCONSAPP -> c7:null_MAPCONSAPP mapconsapp :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp -> Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp null_permute :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp null_revapp :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp null_select :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp null_mapconsapp :: Cons:Nil:null_permute:null_revapp:null_select:null_mapconsapp null_SELECT :: c:c1:c2:null_SELECT null_REVAPP :: c3:null_REVAPP null_PERMUTE :: c5:null_PERMUTE null_MAPCONSAPP :: c7:null_MAPCONSAPP Rewrite Strategy: INNERMOST ---------------------------------------- (113) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID)) Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction. The constant constructors are abstracted as follows: Nil => 0 null_permute => 0 null_revapp => 0 null_select => 0 null_mapconsapp => 0 null_SELECT => 0 null_REVAPP => 0 null_PERMUTE => 0 null_MAPCONSAPP => 0 ---------------------------------------- (114) Obligation: Complexity RNTS consisting of the following rules: MAPCONSAPP(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 MAPCONSAPP(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, z2, z3) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z'' = z3, z2 >= 0, z3 >= 0 PERMUTE(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 PERMUTE(z) -{ 1 }-> 1 + SELECT(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 REVAPP(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 REVAPP(z, z') -{ 1 }-> 1 + REVAPP(z1, 1 + z0 + z2) :|: z1 >= 0, z' = z2, z0 >= 0, z = 1 + z0 + z1, z2 >= 0 SELECT(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(revapp(z1, 1 + z2 + z3)), select(z2, 1 + z0 + z1, z3)) + SELECT(z2, 1 + z0 + z1, z3) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(revapp(z1, 0)), 0) + PERMUTE(revapp(z1, 0)) + REVAPP(z1, 0) :|: z'' = 0, z = z0, z1 >= 0, z' = z1, z0 >= 0 SELECT(z, z', z'') -{ 1 }-> 1 + MAPCONSAPP(z0, permute(revapp(z1, 1 + z2 + z3)), select(z2, 1 + z0 + z1, z3)) + PERMUTE(revapp(z1, 1 + z2 + z3)) + REVAPP(z1, 1 + z2 + z3) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 mapconsapp(z, z', z'') -{ 0 }-> z1 :|: z = z0, z1 >= 0, z0 >= 0, z' = 0, z'' = z1 mapconsapp(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 mapconsapp(z, z', z'') -{ 0 }-> 1 + (1 + z0 + z1) + mapconsapp(z0, z2, z3) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z'' = z3, z2 >= 0, z3 >= 0 permute(z) -{ 0 }-> select(z0, 0, z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 permute(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 permute(z) -{ 0 }-> 1 + 0 + 0 :|: z = 0 revapp(z, z') -{ 0 }-> z0 :|: z0 >= 0, z = 0, z' = z0 revapp(z, z') -{ 0 }-> revapp(z1, 1 + z0 + z2) :|: z1 >= 0, z' = z2, z0 >= 0, z = 1 + z0 + z1, z2 >= 0 revapp(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(revapp(z1, 0)), 0) :|: z'' = 0, z = z0, z1 >= 0, z' = z1, z0 >= 0 select(z, z', z'') -{ 0 }-> mapconsapp(z0, permute(revapp(z1, 1 + z2 + z3)), select(z2, 1 + z0 + z1, z3)) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0, z'' = 1 + z2 + z3, z2 >= 0, z3 >= 0 select(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 Only complete derivations are relevant for the runtime complexity. ---------------------------------------- (115) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) We considered the (Usable) Rules: revapp(Nil, z0) -> z0 revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) And the Tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) The order we found is given by the following interpretation: Polynomial interpretation : POL(Cons(x_1, x_2)) = [1] + x_2 POL(MAPCONSAPP(x_1, x_2, x_3)) = 0 POL(Nil) = 0 POL(PERMUTE(x_1)) = x_1 POL(REVAPP(x_1, x_2)) = 0 POL(SELECT(x_1, x_2, x_3)) = x_2 + x_3 POL(c(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c1(x_1, x_2)) = x_1 + x_2 POL(c2(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(mapconsapp(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3 POL(permute(x_1)) = [1] POL(revapp(x_1, x_2)) = x_1 + x_2 POL(select(x_1, x_2, x_3)) = 0 ---------------------------------------- (116) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) S tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: SELECT_3, REVAPP_2, PERMUTE_1, MAPCONSAPP_3 Compound Symbols: c_3, c1_2, c2_3, c3_1, c5_1, c7_1 ---------------------------------------- (117) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) We considered the (Usable) Rules: revapp(Nil, z0) -> z0 revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) And the Tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) The order we found is given by the following interpretation: Polynomial interpretation : POL(Cons(x_1, x_2)) = [1] + x_2 POL(MAPCONSAPP(x_1, x_2, x_3)) = 0 POL(Nil) = 0 POL(PERMUTE(x_1)) = x_1 POL(REVAPP(x_1, x_2)) = 0 POL(SELECT(x_1, x_2, x_3)) = [1] + x_2 + x_3 POL(c(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c1(x_1, x_2)) = x_1 + x_2 POL(c2(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(mapconsapp(x_1, x_2, x_3)) = [3] + [3]x_1 + [3]x_3 POL(permute(x_1)) = 0 POL(revapp(x_1, x_2)) = x_1 + x_2 POL(select(x_1, x_2, x_3)) = 0 ---------------------------------------- (118) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) S tuples: SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: SELECT_3, REVAPP_2, PERMUTE_1, MAPCONSAPP_3 Compound Symbols: c_3, c1_2, c2_3, c3_1, c5_1, c7_1 ---------------------------------------- (119) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) by SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), PERMUTE(revapp(x1, Cons(z0, Cons(z2, z3)))), REVAPP(x1, Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), PERMUTE(revapp(x1, Cons(z0, Nil))), REVAPP(x1, Cons(z0, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, x3))), REVAPP(Cons(z0, z1), Cons(x2, x3))) SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3))), REVAPP(Nil, Cons(x2, x3))) ---------------------------------------- (120) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), PERMUTE(revapp(x1, Cons(z0, Cons(z2, z3)))), REVAPP(x1, Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), PERMUTE(revapp(x1, Cons(z0, Nil))), REVAPP(x1, Cons(z0, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, x3))), REVAPP(Cons(z0, z1), Cons(x2, x3))) SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3))), REVAPP(Nil, Cons(x2, x3))) S tuples: SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: SELECT_3, REVAPP_2, PERMUTE_1, MAPCONSAPP_3 Compound Symbols: c1_2, c2_3, c3_1, c5_1, c7_1, c_3 ---------------------------------------- (121) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (122) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), PERMUTE(revapp(x1, Cons(z0, Cons(z2, z3)))), REVAPP(x1, Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), PERMUTE(revapp(x1, Cons(z0, Nil))), REVAPP(x1, Cons(z0, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, x3))), REVAPP(Cons(z0, z1), Cons(x2, x3))) SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3)))) S tuples: SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: SELECT_3, REVAPP_2, PERMUTE_1, MAPCONSAPP_3 Compound Symbols: c1_2, c2_3, c3_1, c5_1, c7_1, c_3, c_2 ---------------------------------------- (123) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(z0, z1, Cons(z2, z3)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), SELECT(z2, Cons(z0, z1), z3)) by SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) ---------------------------------------- (124) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), PERMUTE(revapp(x1, Cons(z0, Cons(z2, z3)))), REVAPP(x1, Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), PERMUTE(revapp(x1, Cons(z0, Nil))), REVAPP(x1, Cons(z0, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, x3))), REVAPP(Cons(z0, z1), Cons(x2, x3))) SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3)))) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: SELECT_3, REVAPP_2, PERMUTE_1, MAPCONSAPP_3 Compound Symbols: c2_3, c3_1, c5_1, c7_1, c_3, c_2, c1_2, c1_1 ---------------------------------------- (125) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) ---------------------------------------- (126) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), PERMUTE(revapp(x1, Cons(z0, Cons(z2, z3)))), REVAPP(x1, Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), PERMUTE(revapp(x1, Cons(z0, Nil))), REVAPP(x1, Cons(z0, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, x3))), REVAPP(Cons(z0, z1), Cons(x2, x3))) SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3)))) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: SELECT_3, REVAPP_2, PERMUTE_1, MAPCONSAPP_3 Compound Symbols: c2_3, c3_1, c5_1, c7_1, c_3, c_2, c1_2, c1_1 ---------------------------------------- (127) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) by SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil)), REVAPP(Nil, Nil)) ---------------------------------------- (128) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), PERMUTE(revapp(x1, Cons(z0, Cons(z2, z3)))), REVAPP(x1, Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), PERMUTE(revapp(x1, Cons(z0, Nil))), REVAPP(x1, Cons(z0, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, x3))), REVAPP(Cons(z0, z1), Cons(x2, x3))) SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3)))) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil)), REVAPP(Nil, Nil)) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c_3, c_2, c1_2, c1_1, c2_3 ---------------------------------------- (129) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (130) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), PERMUTE(revapp(x1, Cons(z0, Cons(z2, z3)))), REVAPP(x1, Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), PERMUTE(revapp(x1, Cons(z0, Nil))), REVAPP(x1, Cons(z0, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, x3))), REVAPP(Cons(z0, z1), Cons(x2, x3))) SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3)))) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c_3, c_2, c1_2, c1_1, c2_3, c2_2 ---------------------------------------- (131) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), PERMUTE(revapp(x1, Cons(z0, Cons(z2, z3)))), REVAPP(x1, Cons(z0, Cons(z2, z3)))) by SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4)))), REVAPP(Nil, Cons(x2, Cons(x3, x4)))) ---------------------------------------- (132) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), PERMUTE(revapp(x1, Cons(z0, Nil))), REVAPP(x1, Cons(z0, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, x3))), REVAPP(Cons(z0, z1), Cons(x2, x3))) SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3)))) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4)))), REVAPP(Nil, Cons(x2, Cons(x3, x4)))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c_3, c_2, c1_2, c1_1, c2_3, c2_2 ---------------------------------------- (133) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (134) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), PERMUTE(revapp(x1, Cons(z0, Nil))), REVAPP(x1, Cons(z0, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, x3))), REVAPP(Cons(z0, z1), Cons(x2, x3))) SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3)))) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c_3, c_2, c1_2, c1_1, c2_3, c2_2 ---------------------------------------- (135) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(x0, x1, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), PERMUTE(revapp(x1, Cons(z0, Nil))), REVAPP(x1, Cons(z0, Nil))) by SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil))), REVAPP(Nil, Cons(x2, Nil))) ---------------------------------------- (136) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, x3))), REVAPP(Cons(z0, z1), Cons(x2, x3))) SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3)))) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil))), REVAPP(Nil, Cons(x2, Nil))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c_3, c_2, c1_2, c1_1, c2_3, c2_2 ---------------------------------------- (137) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (138) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, x3))), REVAPP(Cons(z0, z1), Cons(x2, x3))) SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3)))) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c_3, c_2, c1_2, c1_1, c2_3, c2_2 ---------------------------------------- (139) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, x3))), REVAPP(Cons(z0, z1), Cons(x2, x3))) by SELECT(x0, Cons(x1, x2), Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(revapp(x2, Cons(x1, Cons(z0, Cons(z2, z3))))), mapconsapp(z0, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Cons(x1, x2))), z3))), PERMUTE(revapp(Cons(x1, x2), Cons(z0, Cons(z2, z3)))), REVAPP(Cons(x1, x2), Cons(z0, Cons(z2, z3)))) SELECT(x0, Cons(x1, x2), Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x2, Cons(x1, Cons(z0, Nil)))), mapconsapp(z0, permute(revapp(Cons(x0, Cons(x1, x2)), Nil)), Nil)), PERMUTE(revapp(Cons(x1, x2), Cons(z0, Nil))), REVAPP(Cons(x1, x2), Cons(z0, Nil))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) ---------------------------------------- (140) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3)))) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c_2, c1_2, c1_1, c2_3, c2_2, c_3 ---------------------------------------- (141) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(x0, Nil, Cons(x2, x3)) -> c(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), PERMUTE(revapp(Nil, Cons(x2, x3)))) by SELECT(x0, Nil, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(Cons(z0, Cons(z2, z3))), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Nil)), z3))), PERMUTE(revapp(Nil, Cons(z0, Cons(z2, z3))))) SELECT(x0, Nil, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(z0, Nil)), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(z0, Nil)))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) ---------------------------------------- (142) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c_3, c_2, c_1 ---------------------------------------- (143) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(x0, x1, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, x1)), z3))), SELECT(z0, Cons(x0, x1), Cons(z2, z3))) by SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) ---------------------------------------- (144) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c_3, c_2, c_1 ---------------------------------------- (145) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) ---------------------------------------- (146) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c_3, c_2, c_1 ---------------------------------------- (147) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(x0, x1, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x0, x1), Nil)), Nil)), SELECT(z0, Cons(x0, x1), Nil)) by SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) ---------------------------------------- (148) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c_3, c_2, c_1 ---------------------------------------- (149) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) ---------------------------------------- (150) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c_3, c_2, c_1 ---------------------------------------- (151) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(x0, Cons(z0, z1), Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, x3)))), select(x2, Cons(x0, Cons(z0, z1)), x3)), SELECT(x2, Cons(x0, Cons(z0, z1)), x3)) by SELECT(x0, Cons(x1, x2), Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x2, Cons(x1, Cons(z0, Cons(z2, z3))))), mapconsapp(z0, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Cons(x1, x2))), z3))), SELECT(z0, Cons(x0, Cons(x1, x2)), Cons(z2, z3))) SELECT(x0, Cons(x1, x2), Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x2, Cons(x1, Cons(z0, Nil)))), mapconsapp(z0, permute(revapp(Cons(x0, Cons(x1, x2)), Nil)), Nil)), SELECT(z0, Cons(x0, Cons(x1, x2)), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) ---------------------------------------- (152) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c_3, c_2, c_1 ---------------------------------------- (153) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) by SELECT(x0, Nil, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(Cons(z0, Cons(z2, z3))), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Nil)), z3))), SELECT(z0, Cons(x0, Nil), Cons(z2, z3))) SELECT(x0, Nil, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(z0, Nil)), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(z0, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) ---------------------------------------- (154) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_1, c2_3, c2_2, c_3, c_2, c_1, c1_2 ---------------------------------------- (155) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(x0, Cons(z0, z1), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Nil))), Nil), PERMUTE(revapp(Cons(z0, z1), Nil)), REVAPP(Cons(z0, z1), Nil)) by SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) ---------------------------------------- (156) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_1, c2_2, c_3, c_2, c_1, c1_2, c2_3 ---------------------------------------- (157) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, permute(Nil), Nil), PERMUTE(revapp(Nil, Nil))) by SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil), PERMUTE(revapp(Nil, Nil))) ---------------------------------------- (158) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil), PERMUTE(revapp(Nil, Nil))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2 ---------------------------------------- (159) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil), PERMUTE(revapp(Nil, Nil))) by SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil), PERMUTE(Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) ---------------------------------------- (160) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil), PERMUTE(Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1 ---------------------------------------- (161) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (162) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1 ---------------------------------------- (163) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), REVAPP(x1, Cons(x2, Cons(z0, Cons(z2, z3))))) by SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) ---------------------------------------- (164) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1 ---------------------------------------- (165) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), PERMUTE(revapp(x1, Cons(x2, Cons(z0, Nil)))), REVAPP(x1, Cons(x2, Cons(z0, Nil)))) by SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) ---------------------------------------- (166) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1 ---------------------------------------- (167) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) by SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) ---------------------------------------- (168) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1 ---------------------------------------- (169) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) by SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) ---------------------------------------- (170) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1 ---------------------------------------- (171) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) by SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) ---------------------------------------- (172) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1 ---------------------------------------- (173) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) by SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) ---------------------------------------- (174) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) S tuples: REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: REVAPP_2, PERMUTE_1, MAPCONSAPP_3, SELECT_3 Compound Symbols: c3_1, c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1 ---------------------------------------- (175) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace REVAPP(Cons(z0, z1), z2) -> c3(REVAPP(z1, Cons(z0, z2))) by REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Nil), Cons(x2, x3)) -> c3(REVAPP(Nil, Cons(x1, Cons(x2, x3)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, Nil), Nil) -> c3(REVAPP(Nil, Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) ---------------------------------------- (176) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Nil), Cons(x2, x3)) -> c3(REVAPP(Nil, Cons(x1, Cons(x2, x3)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, Nil), Nil) -> c3(REVAPP(Nil, Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Nil), Cons(x2, x3)) -> c3(REVAPP(Nil, Cons(x1, Cons(x2, x3)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, Nil), Nil) -> c3(REVAPP(Nil, Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1, c3_1 ---------------------------------------- (177) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (178) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) REVAPP(Cons(x1, Nil), Cons(x2, x3)) -> c3 REVAPP(Cons(x1, Nil), Nil) -> c3 S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) REVAPP(Cons(x1, Nil), Cons(x2, x3)) -> c3 REVAPP(Cons(x1, Nil), Nil) -> c3 K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1, c3_1, c3 ---------------------------------------- (179) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. REVAPP(Cons(x1, Nil), Cons(x2, x3)) -> c3 REVAPP(Cons(x1, Nil), Nil) -> c3 We considered the (Usable) Rules: revapp(Nil, z0) -> z0 revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) And the Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) REVAPP(Cons(x1, Nil), Cons(x2, x3)) -> c3 REVAPP(Cons(x1, Nil), Nil) -> c3 The order we found is given by the following interpretation: Polynomial interpretation : POL(Cons(x_1, x_2)) = [1] + x_2 POL(MAPCONSAPP(x_1, x_2, x_3)) = 0 POL(Nil) = 0 POL(PERMUTE(x_1)) = x_1 POL(REVAPP(x_1, x_2)) = [1] POL(SELECT(x_1, x_2, x_3)) = [1] + x_2 + x_3 POL(c(x_1)) = x_1 POL(c(x_1, x_2)) = x_1 + x_2 POL(c(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c1(x_1)) = x_1 POL(c1(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c2(x_1, x_2)) = x_1 + x_2 POL(c2(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c3) = 0 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(mapconsapp(x_1, x_2, x_3)) = [1] + x_1 POL(permute(x_1)) = 0 POL(revapp(x_1, x_2)) = x_1 + x_2 POL(select(x_1, x_2, x_3)) = 0 ---------------------------------------- (180) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Cons(x3, x4)))), REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) REVAPP(Cons(x1, Nil), Cons(x2, x3)) -> c3 REVAPP(Cons(x1, Nil), Nil) -> c3 S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) REVAPP(Cons(x1, Nil), Cons(x2, x3)) -> c3 REVAPP(Cons(x1, Nil), Nil) -> c3 Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1, c3_1, c3 ---------------------------------------- (181) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Cons(x1, x2), Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(revapp(x2, Cons(x1, Cons(z0, Cons(z2, z3))))), mapconsapp(z0, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Cons(x1, x2))), z3))), PERMUTE(revapp(Cons(x1, x2), Cons(z0, Cons(z2, z3)))), REVAPP(Cons(x1, x2), Cons(z0, Cons(z2, z3)))) by SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) ---------------------------------------- (182) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), PERMUTE(revapp(Nil, Cons(x2, Cons(x3, x4))))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), PERMUTE(revapp(Cons(z0, z1), Cons(x2, Nil))), REVAPP(Cons(z0, z1), Cons(x2, Nil))) SELECT(x0, Nil, Cons(x2, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(x2, Nil)))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) REVAPP(Cons(x1, Nil), Cons(x2, x3)) -> c3 REVAPP(Cons(x1, Nil), Nil) -> c3 S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(z0, z1, Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)), PERMUTE(revapp(z1, Cons(z2, z3))), REVAPP(z1, Cons(z2, z3))) SELECT(z0, z1, Nil) -> c2(MAPCONSAPP(z0, permute(revapp(z1, Nil)), Nil), PERMUTE(revapp(z1, Nil)), REVAPP(z1, Nil)) SELECT(x0, Nil, Cons(x2, x3)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, x3)), select(x2, Cons(x0, Nil), x3)), SELECT(x2, Cons(x0, Nil), x3)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) REVAPP(Cons(x1, Nil), Cons(x2, x3)) -> c3 REVAPP(Cons(x1, Nil), Nil) -> c3 Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1, c3_1, c3 ---------------------------------------- (183) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing nodes: REVAPP(Cons(x1, Nil), Cons(x2, x3)) -> c3 REVAPP(Cons(x1, Nil), Nil) -> c3 ---------------------------------------- (184) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(x1, x2), Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x2, Cons(x1, Cons(z0, Nil)))), mapconsapp(z0, permute(revapp(Cons(x0, Cons(x1, x2)), Nil)), Nil)), PERMUTE(revapp(Cons(x1, x2), Cons(z0, Nil))), REVAPP(Cons(x1, x2), Cons(z0, Nil))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(Cons(z0, Cons(z2, z3))), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Nil)), z3))), PERMUTE(revapp(Nil, Cons(z0, Cons(z2, z3))))) SELECT(x0, Nil, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(z0, Nil)), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(z0, Nil)))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1, c3_1 ---------------------------------------- (185) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Cons(x1, x2), Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(x2, Cons(x1, Cons(z0, Nil)))), mapconsapp(z0, permute(revapp(Cons(x0, Cons(x1, x2)), Nil)), Nil)), PERMUTE(revapp(Cons(x1, x2), Cons(z0, Nil))), REVAPP(Cons(x1, x2), Cons(z0, Nil))) by SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) ---------------------------------------- (186) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(Cons(z0, Cons(z2, z3))), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Nil)), z3))), PERMUTE(revapp(Nil, Cons(z0, Cons(z2, z3))))) SELECT(x0, Nil, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(z0, Nil)), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(z0, Nil)))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1, c3_1 ---------------------------------------- (187) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Cons(x3, x4))), REVAPP(Cons(x1, Cons(z0, z1)), Cons(x3, x4))) by SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) ---------------------------------------- (188) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(Cons(z0, Cons(z2, z3))), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Nil)), z3))), PERMUTE(revapp(Nil, Cons(z0, Cons(z2, z3))))) SELECT(x0, Nil, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(z0, Nil)), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(z0, Nil)))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1, c3_1 ---------------------------------------- (189) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), PERMUTE(revapp(Cons(x1, Nil), Cons(x3, x4))), REVAPP(Cons(x1, Nil), Cons(x3, x4))) by SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) ---------------------------------------- (190) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) SELECT(x0, Nil, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(Cons(z0, Cons(z2, z3))), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Nil)), z3))), PERMUTE(revapp(Nil, Cons(z0, Cons(z2, z3))))) SELECT(x0, Nil, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(z0, Nil)), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(z0, Nil)))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1, c3_1 ---------------------------------------- (191) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c(PERMUTE(revapp(Cons(x1, x2), Cons(x3, x4))), REVAPP(Cons(x1, x2), Cons(x3, x4))) by SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) ---------------------------------------- (192) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Nil, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(Cons(z0, Cons(z2, z3))), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Nil)), z3))), PERMUTE(revapp(Nil, Cons(z0, Cons(z2, z3))))) SELECT(x0, Nil, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(z0, Nil)), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(z0, Nil)))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1, c3_1 ---------------------------------------- (193) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Nil, Cons(z0, Cons(z2, z3))) -> c(MAPCONSAPP(x0, permute(Cons(z0, Cons(z2, z3))), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Nil)), z3))), PERMUTE(revapp(Nil, Cons(z0, Cons(z2, z3))))) by SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) ---------------------------------------- (194) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Nil, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(z0, Nil)), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(z0, Nil)))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1, c3_1 ---------------------------------------- (195) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Nil, Cons(z0, Nil)) -> c(MAPCONSAPP(x0, permute(Cons(z0, Nil)), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Nil)), Nil)), PERMUTE(revapp(Nil, Cons(z0, Nil)))) by SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) ---------------------------------------- (196) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c_2, c_1, c1_2, c2_3, c2_2, c2_1, c3_1 ---------------------------------------- (197) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Nil, Cons(z0, z1)) -> c(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), PERMUTE(revapp(Nil, Cons(z0, z1)))) by SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) ---------------------------------------- (198) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c_1, c1_2, c2_3, c2_2, c2_1, c_2, c3_1 ---------------------------------------- (199) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Nil, Cons(x1, x2)) -> c(PERMUTE(revapp(Nil, Cons(x1, x2)))) by SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) ---------------------------------------- (200) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c1_2, c2_3, c2_2, c2_1, c_2, c3_1, c_1 ---------------------------------------- (201) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, x1, Cons(x2, Cons(z0, Cons(z2, z3)))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Cons(z2, z3))))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Cons(z2, z3)))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x2, Cons(x0, x1))), z3)))), SELECT(x2, Cons(x0, x1), Cons(z0, Cons(z2, z3)))) by SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) ---------------------------------------- (202) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c1_2, c2_3, c2_2, c2_1, c_2, c3_1, c_1 ---------------------------------------- (203) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, x1, Cons(x2, Cons(z0, Nil))) -> c1(MAPCONSAPP(x0, permute(revapp(x1, Cons(x2, Cons(z0, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, x1), Cons(z0, Nil))), mapconsapp(z0, permute(revapp(Cons(x2, Cons(x0, x1)), Nil)), Nil))), SELECT(x2, Cons(x0, x1), Cons(z0, Nil))) by SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) ---------------------------------------- (204) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_1, c_3, c1_2, c2_3, c2_2, c2_1, c_2, c3_1, c_1 ---------------------------------------- (205) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace SELECT(x0, x1, Cons(x2, x3)) -> c1(SELECT(x2, Cons(x0, x1), x3)) by SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x2, Cons(x0, x1), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, x1)), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) ---------------------------------------- (206) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c_3, c1_2, c1_1, c2_3, c2_2, c2_1, c_2, c3_1, c_1 ---------------------------------------- (207) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) ---------------------------------------- (208) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c_3, c1_2, c1_1, c2_3, c2_2, c2_1, c_2, c3_1, c_1 ---------------------------------------- (209) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) by SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) ---------------------------------------- (210) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c_3, c1_2, c1_1, c2_3, c2_2, c2_1, c_2, c3_1, c_1 ---------------------------------------- (211) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) by SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) ---------------------------------------- (212) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c_3, c1_2, c1_1, c2_3, c2_2, c2_1, c_2, c3_1, c_1 ---------------------------------------- (213) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), PERMUTE(revapp(z1, Cons(x2, Cons(x3, x4)))), REVAPP(z1, Cons(x2, Cons(x3, x4)))) by SELECT(x0, Nil, Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x0, Nil)), z4))), PERMUTE(revapp(Nil, Cons(z2, Cons(z3, z4)))), REVAPP(Nil, Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Cons(z3, z4)))), select(z3, Cons(x3, Cons(x2, Cons(x0, x1))), z4))), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), REVAPP(Cons(x0, x1), Cons(x3, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Cons(z3, z4)))), select(z3, Cons(x4, Cons(x3, Cons(x0, Cons(x1, x2)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x2, Cons(x0, Cons(x1, Nil)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))) SELECT(x1, Cons(x0, Nil), Cons(x2, Cons(z3, z4))) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Cons(z3, z4)))), select(z3, Cons(x2, Cons(x1, Cons(x0, Nil))), z4))), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), REVAPP(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x3, Cons(x0, Cons(x1, Cons(x2, Nil))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))) ---------------------------------------- (214) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) SELECT(x0, Nil, Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x0, Nil)), z4))), PERMUTE(revapp(Nil, Cons(z2, Cons(z3, z4)))), REVAPP(Nil, Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Cons(z3, z4)))), select(z3, Cons(x3, Cons(x2, Cons(x0, x1))), z4))), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), REVAPP(Cons(x0, x1), Cons(x3, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Cons(z3, z4)))), select(z3, Cons(x4, Cons(x3, Cons(x0, Cons(x1, x2)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x2, Cons(x0, Cons(x1, Nil)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))) SELECT(x1, Cons(x0, Nil), Cons(x2, Cons(z3, z4))) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Cons(z3, z4)))), select(z3, Cons(x2, Cons(x1, Cons(x0, Nil))), z4))), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), REVAPP(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x3, Cons(x0, Cons(x1, Cons(x2, Nil))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c_3, c1_2, c1_1, c2_3, c2_2, c2_1, c_2, c3_1, c_1 ---------------------------------------- (215) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (216) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Cons(z3, z4)))), select(z3, Cons(x3, Cons(x2, Cons(x0, x1))), z4))), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), REVAPP(Cons(x0, x1), Cons(x3, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Cons(z3, z4)))), select(z3, Cons(x4, Cons(x3, Cons(x0, Cons(x1, x2)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x2, Cons(x0, Cons(x1, Nil)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))) SELECT(x1, Cons(x0, Nil), Cons(x2, Cons(z3, z4))) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Cons(z3, z4)))), select(z3, Cons(x2, Cons(x1, Cons(x0, Nil))), z4))), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), REVAPP(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x3, Cons(x0, Cons(x1, Cons(x2, Nil))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))) SELECT(x0, Nil, Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x0, Nil)), z4))), PERMUTE(revapp(Nil, Cons(z2, Cons(z3, z4))))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c_3, c1_2, c1_1, c2_3, c2_2, c2_1, c_2, c3_1, c_1 ---------------------------------------- (217) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace SELECT(z0, z1, Cons(x2, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), PERMUTE(revapp(z1, Cons(x2, Nil))), REVAPP(z1, Cons(x2, Nil))) by SELECT(x0, Nil, Cons(z2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Nil))), Nil)), PERMUTE(revapp(Nil, Cons(z2, Nil))), REVAPP(Nil, Cons(z2, Nil))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Nil))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Nil))), REVAPP(Cons(x0, x1), Cons(x3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil)) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))) SELECT(x1, Cons(x0, Nil), Cons(x2, Nil)) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Nil))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Nil))), REVAPP(Cons(x0, Nil), Cons(x2, Nil))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil)) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))) ---------------------------------------- (218) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Cons(z3, z4)))), select(z3, Cons(x3, Cons(x2, Cons(x0, x1))), z4))), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), REVAPP(Cons(x0, x1), Cons(x3, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Cons(z3, z4)))), select(z3, Cons(x4, Cons(x3, Cons(x0, Cons(x1, x2)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x2, Cons(x0, Cons(x1, Nil)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))) SELECT(x1, Cons(x0, Nil), Cons(x2, Cons(z3, z4))) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Cons(z3, z4)))), select(z3, Cons(x2, Cons(x1, Cons(x0, Nil))), z4))), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), REVAPP(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x3, Cons(x0, Cons(x1, Cons(x2, Nil))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))) SELECT(x0, Nil, Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x0, Nil)), z4))), PERMUTE(revapp(Nil, Cons(z2, Cons(z3, z4))))) SELECT(x0, Nil, Cons(z2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Nil))), Nil)), PERMUTE(revapp(Nil, Cons(z2, Nil))), REVAPP(Nil, Cons(z2, Nil))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Nil))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Nil))), REVAPP(Cons(x0, x1), Cons(x3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil)) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))) SELECT(x1, Cons(x0, Nil), Cons(x2, Nil)) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Nil))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Nil))), REVAPP(Cons(x0, Nil), Cons(x2, Nil))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil)) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c2_1, c_3, c_2, c3_1, c_1 ---------------------------------------- (219) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (220) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Cons(z3, z4)))), select(z3, Cons(x3, Cons(x2, Cons(x0, x1))), z4))), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), REVAPP(Cons(x0, x1), Cons(x3, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Cons(z3, z4)))), select(z3, Cons(x4, Cons(x3, Cons(x0, Cons(x1, x2)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x2, Cons(x0, Cons(x1, Nil)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))) SELECT(x1, Cons(x0, Nil), Cons(x2, Cons(z3, z4))) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Cons(z3, z4)))), select(z3, Cons(x2, Cons(x1, Cons(x0, Nil))), z4))), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), REVAPP(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x3, Cons(x0, Cons(x1, Cons(x2, Nil))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))) SELECT(x0, Nil, Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x0, Nil)), z4))), PERMUTE(revapp(Nil, Cons(z2, Cons(z3, z4))))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Nil))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Nil))), REVAPP(Cons(x0, x1), Cons(x3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil)) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))) SELECT(x1, Cons(x0, Nil), Cons(x2, Nil)) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Nil))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Nil))), REVAPP(Cons(x0, Nil), Cons(x2, Nil))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil)) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))) SELECT(x0, Nil, Cons(z2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Nil))), Nil)), PERMUTE(revapp(Nil, Cons(z2, Nil)))) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c2_1, c_3, c_2, c3_1, c_1 ---------------------------------------- (221) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) by SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) ---------------------------------------- (222) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Cons(z3, z4)))), select(z3, Cons(x3, Cons(x2, Cons(x0, x1))), z4))), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), REVAPP(Cons(x0, x1), Cons(x3, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Cons(z3, z4)))), select(z3, Cons(x4, Cons(x3, Cons(x0, Cons(x1, x2)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x2, Cons(x0, Cons(x1, Nil)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))) SELECT(x1, Cons(x0, Nil), Cons(x2, Cons(z3, z4))) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Cons(z3, z4)))), select(z3, Cons(x2, Cons(x1, Cons(x0, Nil))), z4))), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), REVAPP(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x3, Cons(x0, Cons(x1, Cons(x2, Nil))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))) SELECT(x0, Nil, Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x0, Nil)), z4))), PERMUTE(revapp(Nil, Cons(z2, Cons(z3, z4))))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Nil))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Nil))), REVAPP(Cons(x0, x1), Cons(x3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil)) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))) SELECT(x1, Cons(x0, Nil), Cons(x2, Nil)) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Nil))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Nil))), REVAPP(Cons(x0, Nil), Cons(x2, Nil))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil)) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))) SELECT(x0, Nil, Cons(z2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Nil))), Nil)), PERMUTE(revapp(Nil, Cons(z2, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c2_1, c_3, c_2, c3_1, c_1 ---------------------------------------- (223) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) by SELECT(z0, Nil, Cons(z1, Nil)) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Nil))), Nil)), SELECT(z1, Cons(z0, Nil), Nil)) ---------------------------------------- (224) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Cons(x3, x4))))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Cons(z0, z1))), x4))), SELECT(x2, Cons(x0, Cons(z0, z1)), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Cons(z3, z4)))), select(z3, Cons(x3, Cons(x2, Cons(x0, x1))), z4))), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), REVAPP(Cons(x0, x1), Cons(x3, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Cons(z3, z4)))), select(z3, Cons(x4, Cons(x3, Cons(x0, Cons(x1, x2)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x2, Cons(x0, Cons(x1, Nil)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))) SELECT(x1, Cons(x0, Nil), Cons(x2, Cons(z3, z4))) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Cons(z3, z4)))), select(z3, Cons(x2, Cons(x1, Cons(x0, Nil))), z4))), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), REVAPP(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x3, Cons(x0, Cons(x1, Cons(x2, Nil))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))) SELECT(x0, Nil, Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x0, Nil)), z4))), PERMUTE(revapp(Nil, Cons(z2, Cons(z3, z4))))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Nil))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Nil))), REVAPP(Cons(x0, x1), Cons(x3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil)) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))) SELECT(x1, Cons(x0, Nil), Cons(x2, Nil)) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Nil))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Nil))), REVAPP(Cons(x0, Nil), Cons(x2, Nil))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil)) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))) SELECT(x0, Nil, Cons(z2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Nil))), Nil)), PERMUTE(revapp(Nil, Cons(z2, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) SELECT(z0, Nil, Cons(z1, Nil)) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Nil))), Nil)), SELECT(z1, Cons(z0, Nil), Nil)) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c2_1, c_3, c_2, c3_1, c_1 ---------------------------------------- (225) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Cons(x1, x2), Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(revapp(x2, Cons(x1, Cons(z0, Cons(z2, z3))))), mapconsapp(z0, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Cons(x1, x2))), z3))), SELECT(z0, Cons(x0, Cons(x1, x2)), Cons(z2, z3))) by SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) ---------------------------------------- (226) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Cons(z0, z1), Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x2, Nil)))), mapconsapp(x2, permute(revapp(Cons(x0, Cons(z0, z1)), Nil)), Nil)), SELECT(x2, Cons(x0, Cons(z0, z1)), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Cons(z3, z4)))), select(z3, Cons(x3, Cons(x2, Cons(x0, x1))), z4))), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), REVAPP(Cons(x0, x1), Cons(x3, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Cons(z3, z4)))), select(z3, Cons(x4, Cons(x3, Cons(x0, Cons(x1, x2)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x2, Cons(x0, Cons(x1, Nil)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))) SELECT(x1, Cons(x0, Nil), Cons(x2, Cons(z3, z4))) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Cons(z3, z4)))), select(z3, Cons(x2, Cons(x1, Cons(x0, Nil))), z4))), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), REVAPP(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x3, Cons(x0, Cons(x1, Cons(x2, Nil))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))) SELECT(x0, Nil, Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x0, Nil)), z4))), PERMUTE(revapp(Nil, Cons(z2, Cons(z3, z4))))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Nil))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Nil))), REVAPP(Cons(x0, x1), Cons(x3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil)) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))) SELECT(x1, Cons(x0, Nil), Cons(x2, Nil)) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Nil))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Nil))), REVAPP(Cons(x0, Nil), Cons(x2, Nil))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil)) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))) SELECT(x0, Nil, Cons(z2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Nil))), Nil)), PERMUTE(revapp(Nil, Cons(z2, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) SELECT(z0, Nil, Cons(z1, Nil)) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Nil))), Nil)), SELECT(z1, Cons(z0, Nil), Nil)) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c2_1, c_3, c_2, c3_1, c_1 ---------------------------------------- (227) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Cons(x1, x2), Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(revapp(x2, Cons(x1, Cons(z0, Nil)))), mapconsapp(z0, permute(revapp(Cons(x0, Cons(x1, x2)), Nil)), Nil)), SELECT(z0, Cons(x0, Cons(x1, x2)), Nil)) by SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) ---------------------------------------- (228) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Cons(z3, z4)))), select(z3, Cons(x3, Cons(x2, Cons(x0, x1))), z4))), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), REVAPP(Cons(x0, x1), Cons(x3, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Cons(z3, z4)))), select(z3, Cons(x4, Cons(x3, Cons(x0, Cons(x1, x2)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x2, Cons(x0, Cons(x1, Nil)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))) SELECT(x1, Cons(x0, Nil), Cons(x2, Cons(z3, z4))) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Cons(z3, z4)))), select(z3, Cons(x2, Cons(x1, Cons(x0, Nil))), z4))), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), REVAPP(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x3, Cons(x0, Cons(x1, Cons(x2, Nil))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))) SELECT(x0, Nil, Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x0, Nil)), z4))), PERMUTE(revapp(Nil, Cons(z2, Cons(z3, z4))))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Nil))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Nil))), REVAPP(Cons(x0, x1), Cons(x3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil)) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))) SELECT(x1, Cons(x0, Nil), Cons(x2, Nil)) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Nil))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Nil))), REVAPP(Cons(x0, Nil), Cons(x2, Nil))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil)) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))) SELECT(x0, Nil, Cons(z2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Nil))), Nil)), PERMUTE(revapp(Nil, Cons(z2, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) SELECT(z0, Nil, Cons(z1, Nil)) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Nil))), Nil)), SELECT(z1, Cons(z0, Nil), Nil)) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c2_1, c_3, c_2, c3_1, c_1 ---------------------------------------- (229) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Cons(x1, Nil), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(Cons(x1, Cons(x3, x4))), select(x3, Cons(x0, Cons(x1, Nil)), x4)), SELECT(x3, Cons(x0, Cons(x1, Nil)), x4)) by SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c1(MAPCONSAPP(z0, select(z1, Nil, Cons(z2, z3)), select(z2, Cons(z0, Cons(z1, Nil)), z3)), SELECT(z2, Cons(z0, Cons(z1, Nil)), z3)) ---------------------------------------- (230) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Cons(z3, z4)))), select(z3, Cons(x3, Cons(x2, Cons(x0, x1))), z4))), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), REVAPP(Cons(x0, x1), Cons(x3, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Cons(z3, z4)))), select(z3, Cons(x4, Cons(x3, Cons(x0, Cons(x1, x2)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x2, Cons(x0, Cons(x1, Nil)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))) SELECT(x1, Cons(x0, Nil), Cons(x2, Cons(z3, z4))) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Cons(z3, z4)))), select(z3, Cons(x2, Cons(x1, Cons(x0, Nil))), z4))), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), REVAPP(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x3, Cons(x0, Cons(x1, Cons(x2, Nil))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))) SELECT(x0, Nil, Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x0, Nil)), z4))), PERMUTE(revapp(Nil, Cons(z2, Cons(z3, z4))))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Nil))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Nil))), REVAPP(Cons(x0, x1), Cons(x3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil)) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))) SELECT(x1, Cons(x0, Nil), Cons(x2, Nil)) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Nil))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Nil))), REVAPP(Cons(x0, Nil), Cons(x2, Nil))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil)) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))) SELECT(x0, Nil, Cons(z2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Nil))), Nil)), PERMUTE(revapp(Nil, Cons(z2, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) SELECT(z0, Nil, Cons(z1, Nil)) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Nil))), Nil)), SELECT(z1, Cons(z0, Nil), Nil)) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c1(MAPCONSAPP(z0, select(z1, Nil, Cons(z2, z3)), select(z2, Cons(z0, Cons(z1, Nil)), z3)), SELECT(z2, Cons(z0, Cons(z1, Nil)), z3)) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c1(MAPCONSAPP(z0, select(z1, Nil, Cons(z2, z3)), select(z2, Cons(z0, Cons(z1, Nil)), z3)), SELECT(z2, Cons(z0, Cons(z1, Nil)), z3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c2_1, c_3, c_2, c3_1, c_1 ---------------------------------------- (231) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Nil, Cons(z0, Cons(z2, z3))) -> c1(MAPCONSAPP(x0, permute(Cons(z0, Cons(z2, z3))), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Cons(z2, z3))), select(z2, Cons(z0, Cons(x0, Nil)), z3))), SELECT(z0, Cons(x0, Nil), Cons(z2, z3))) by SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) ---------------------------------------- (232) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Cons(z3, z4)))), select(z3, Cons(x3, Cons(x2, Cons(x0, x1))), z4))), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), REVAPP(Cons(x0, x1), Cons(x3, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Cons(z3, z4)))), select(z3, Cons(x4, Cons(x3, Cons(x0, Cons(x1, x2)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x2, Cons(x0, Cons(x1, Nil)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))) SELECT(x1, Cons(x0, Nil), Cons(x2, Cons(z3, z4))) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Cons(z3, z4)))), select(z3, Cons(x2, Cons(x1, Cons(x0, Nil))), z4))), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), REVAPP(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x3, Cons(x0, Cons(x1, Cons(x2, Nil))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))) SELECT(x0, Nil, Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x0, Nil)), z4))), PERMUTE(revapp(Nil, Cons(z2, Cons(z3, z4))))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Nil))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Nil))), REVAPP(Cons(x0, x1), Cons(x3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil)) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))) SELECT(x1, Cons(x0, Nil), Cons(x2, Nil)) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Nil))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Nil))), REVAPP(Cons(x0, Nil), Cons(x2, Nil))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil)) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))) SELECT(x0, Nil, Cons(z2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Nil))), Nil)), PERMUTE(revapp(Nil, Cons(z2, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) SELECT(z0, Nil, Cons(z1, Nil)) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Nil))), Nil)), SELECT(z1, Cons(z0, Nil), Nil)) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c1(MAPCONSAPP(z0, select(z1, Nil, Cons(z2, z3)), select(z2, Cons(z0, Cons(z1, Nil)), z3)), SELECT(z2, Cons(z0, Cons(z1, Nil)), z3)) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c1(MAPCONSAPP(z0, select(z1, Nil, Cons(z2, z3)), select(z2, Cons(z0, Cons(z1, Nil)), z3)), SELECT(z2, Cons(z0, Cons(z1, Nil)), z3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c2_1, c_3, c_2, c3_1, c_1 ---------------------------------------- (233) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SELECT(x0, Nil, Cons(z0, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(z0, Nil)), mapconsapp(z0, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(z0, Cons(x0, Nil), Nil)) by SELECT(z0, Nil, Cons(z1, Nil)) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Nil))), Nil)), SELECT(z1, Cons(z0, Nil), Nil)) ---------------------------------------- (234) Obligation: Complexity Dependency Tuples Problem Rules: permute(Cons(z0, z1)) -> select(z0, Nil, z1) permute(Nil) -> Cons(Nil, Nil) revapp(Cons(z0, z1), z2) -> revapp(z1, Cons(z0, z2)) revapp(Nil, z0) -> z0 select(z0, z1, Cons(z2, z3)) -> mapconsapp(z0, permute(revapp(z1, Cons(z2, z3))), select(z2, Cons(z0, z1), z3)) select(z0, z1, Nil) -> mapconsapp(z0, permute(revapp(z1, Nil)), Nil) mapconsapp(z0, Cons(z1, z2), z3) -> Cons(Cons(z0, z1), mapconsapp(z0, z2, z3)) mapconsapp(z0, Nil, z1) -> z1 Tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) SELECT(x0, Nil, Cons(z0, z1)) -> c1(MAPCONSAPP(x0, select(z0, Nil, z1), select(z0, Cons(x0, Nil), z1)), SELECT(z0, Cons(x0, Nil), z1)) SELECT(x0, Cons(x1, Cons(z0, z1)), Nil) -> c2(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Nil)))), Nil), PERMUTE(revapp(Cons(x1, Cons(z0, z1)), Nil)), REVAPP(Cons(x1, Cons(z0, z1)), Nil)) SELECT(x0, Cons(x1, Nil), Nil) -> c2(MAPCONSAPP(x0, permute(Cons(x1, Nil)), Nil), PERMUTE(revapp(Cons(x1, Nil), Nil)), REVAPP(Cons(x1, Nil), Nil)) SELECT(x0, Cons(x1, x2), Nil) -> c2(PERMUTE(revapp(Cons(x1, x2), Nil)), REVAPP(Cons(x1, x2), Nil)) SELECT(x0, Nil, Nil) -> c2(MAPCONSAPP(x0, Cons(Nil, Nil), Nil)) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), REVAPP(z1, Cons(z2, Cons(z3, Cons(z4, z5))))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), PERMUTE(revapp(z1, Cons(z2, Cons(z3, Nil)))), REVAPP(z1, Cons(z2, Cons(z3, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Cons(z4, z5))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), REVAPP(Cons(z1, z2), Cons(z3, Cons(z4, z5)))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Cons(z2, z3))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), PERMUTE(Cons(z1, Cons(z2, z3)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z0, Cons(z1, z2)), Nil)), Nil)), PERMUTE(revapp(z2, Cons(z1, Cons(z3, Nil)))), REVAPP(Cons(z1, z2), Cons(z3, Nil))) SELECT(z0, Nil, Cons(z1, Nil)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Cons(z0, Nil), Nil)), Nil)), PERMUTE(Cons(z1, Nil))) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, Cons(z1, Cons(z2, z3)), Cons(z4, z5)) -> c(MAPCONSAPP(z0, permute(revapp(z3, Cons(z2, Cons(z1, Cons(z4, z5))))), select(z4, Cons(z0, Cons(z1, Cons(z2, z3))), z5)), PERMUTE(revapp(Cons(z2, z3), Cons(z1, Cons(z4, z5)))), REVAPP(Cons(z1, Cons(z2, z3)), Cons(z4, z5))) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), select(z2, Cons(z0, Cons(z1, Nil)), z3)), PERMUTE(revapp(Nil, Cons(z1, Cons(z2, z3)))), REVAPP(Cons(z1, Nil), Cons(z2, z3))) SELECT(z0, Cons(z1, z2), Cons(z3, z4)) -> c(PERMUTE(revapp(z2, Cons(z1, Cons(z3, z4)))), REVAPP(Cons(z1, z2), Cons(z3, z4))) SELECT(z0, Nil, Cons(z1, z2)) -> c(MAPCONSAPP(z0, select(z1, Nil, z2), select(z1, Cons(z0, Nil), z2)), PERMUTE(Cons(z1, z2))) SELECT(z0, Nil, Cons(z1, z2)) -> c(PERMUTE(Cons(z1, z2))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Nil, Cons(z1, Cons(z2, z3))) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Cons(z2, z3))), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Cons(z2, z3)))), select(z2, Cons(z1, Cons(z0, Nil)), z3))), SELECT(z1, Cons(z0, Nil), Cons(z2, z3))) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Cons(z3, z4)))), select(z3, Cons(x3, Cons(x2, Cons(x0, x1))), z4))), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Cons(z3, z4)))), REVAPP(Cons(x0, x1), Cons(x3, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Cons(z3, z4)))), select(z3, Cons(x4, Cons(x3, Cons(x0, Cons(x1, x2)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Cons(z3, z4)))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Cons(z3, z4)))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x2, Cons(x0, Cons(x1, Nil)))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Cons(z3, z4)))) SELECT(x1, Cons(x0, Nil), Cons(x2, Cons(z3, z4))) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Cons(z3, z4)))), select(z3, Cons(x2, Cons(x1, Cons(x0, Nil))), z4))), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))), REVAPP(Cons(x0, Nil), Cons(x2, Cons(z3, z4)))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Cons(z3, z4)))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x3, Cons(x0, Cons(x1, Cons(x2, Nil))))), z4))), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Cons(z3, z4)))) SELECT(x0, Nil, Cons(z2, Cons(z3, z4))) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Cons(z3, z4)))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Cons(z3, z4)))), select(z3, Cons(z2, Cons(x0, Nil)), z4))), PERMUTE(revapp(Nil, Cons(z2, Cons(z3, z4))))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, x1), Cons(x3, Nil))), mapconsapp(x3, permute(revapp(Cons(x0, x1), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, x1), Cons(x3, Nil))), REVAPP(Cons(x0, x1), Cons(x3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), mapconsapp(x4, permute(revapp(Cons(x0, Cons(x1, x2)), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))), REVAPP(Cons(x0, Cons(x1, x2)), Cons(x4, Nil))) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil)) -> c(MAPCONSAPP(x4, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x4, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, Nil))) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, Nil)) -> c(MAPCONSAPP(x2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Nil)), Cons(x2, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Nil)), Cons(z2, Nil))) SELECT(x1, Cons(x0, Nil), Cons(x2, Nil)) -> c(MAPCONSAPP(x1, permute(revapp(Cons(x0, Nil), Cons(x2, Nil))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x1, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Nil), Cons(x2, Nil))), REVAPP(Cons(x0, Nil), Cons(x2, Nil))) SELECT(x5, Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil)) -> c(MAPCONSAPP(x5, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x5, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(z2, Nil))) SELECT(x3, Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil)) -> c(MAPCONSAPP(x3, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(x3, Nil))), Nil)), PERMUTE(revapp(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))), REVAPP(Cons(x0, Cons(x1, Cons(x2, Nil))), Cons(z2, Nil))) SELECT(x0, Nil, Cons(z2, Nil)) -> c(MAPCONSAPP(x0, permute(revapp(Nil, Cons(z2, Nil))), mapconsapp(z2, permute(revapp(Nil, Cons(x0, Nil))), Nil)), PERMUTE(revapp(Nil, Cons(z2, Nil)))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) SELECT(z0, Nil, Cons(z1, Nil)) -> c1(MAPCONSAPP(z0, permute(Cons(z1, Nil)), mapconsapp(z1, permute(revapp(Nil, Cons(z0, Nil))), Nil)), SELECT(z1, Cons(z0, Nil), Nil)) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c1(MAPCONSAPP(z0, select(z1, Nil, Cons(z2, z3)), select(z2, Cons(z0, Cons(z1, Nil)), z3)), SELECT(z2, Cons(z0, Cons(z1, Nil)), z3)) S tuples: MAPCONSAPP(z0, Cons(z1, z2), z3) -> c7(MAPCONSAPP(z0, z2, z3)) SELECT(z0, z1, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Cons(x3, x4)))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Cons(x3, x4)))), select(x3, Cons(x2, Cons(z0, z1)), x4))), SELECT(x2, Cons(z0, z1), Cons(x3, x4))) SELECT(x0, x1, Cons(x2, Cons(x3, x4))) -> c1(SELECT(x2, Cons(x0, x1), Cons(x3, x4))) SELECT(z0, z1, Cons(x2, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(x2, Nil))), mapconsapp(x2, permute(revapp(z1, Cons(z0, Nil))), Nil)), SELECT(x2, Cons(z0, z1), Nil)) SELECT(x0, x1, Cons(x2, Nil)) -> c1(SELECT(x2, Cons(x0, x1), Nil)) SELECT(x0, Cons(x1, Cons(z0, z1)), Cons(x3, x4)) -> c1(MAPCONSAPP(x0, permute(revapp(z1, Cons(z0, Cons(x1, Cons(x3, x4))))), select(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)), SELECT(x3, Cons(x0, Cons(x1, Cons(z0, z1))), x4)) SELECT(x0, Cons(x1, x2), Cons(x3, x4)) -> c1(SELECT(x3, Cons(x0, Cons(x1, x2)), x4)) REVAPP(Cons(z0, z1), Cons(x0, x2)) -> c3(REVAPP(z1, Cons(z0, Cons(x0, x2)))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, x4))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, x4))))) REVAPP(Cons(z0, z1), Cons(x2, Nil)) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Nil)))) REVAPP(Cons(x1, Cons(x2, x3)), Cons(x4, x5)) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Cons(x4, x5)))) REVAPP(Cons(x1, Cons(x2, x3)), Nil) -> c3(REVAPP(Cons(x2, x3), Cons(x1, Nil))) REVAPP(Cons(x1, x2), Nil) -> c3(REVAPP(x2, Cons(x1, Nil))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Cons(x4, x5)))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Cons(x4, x5)))))) REVAPP(Cons(z0, z1), Cons(x2, Cons(x3, Nil))) -> c3(REVAPP(z1, Cons(z0, Cons(x2, Cons(x3, Nil))))) SELECT(z0, z1, Cons(z2, Cons(z3, Cons(z4, z5)))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Cons(z4, z5))))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Cons(z4, z5)))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z2, Cons(z0, z1))), z5)))), SELECT(z2, Cons(z0, z1), Cons(z3, Cons(z4, z5)))) SELECT(z0, z1, Cons(z2, Cons(z3, Nil))) -> c1(MAPCONSAPP(z0, permute(revapp(z1, Cons(z2, Cons(z3, Nil)))), mapconsapp(z2, permute(revapp(Cons(z0, z1), Cons(z3, Nil))), mapconsapp(z3, permute(revapp(Cons(z0, z1), Cons(z2, Nil))), Nil))), SELECT(z2, Cons(z0, z1), Cons(z3, Nil))) SELECT(x3, Cons(x0, Cons(x1, x2)), Cons(x4, x5)) -> c1(SELECT(x4, Cons(x3, Cons(x0, Cons(x1, x2))), x5)) SELECT(x1, Cons(x0, Nil), Cons(x2, x3)) -> c1(SELECT(x2, Cons(x1, Cons(x0, Nil)), x3)) SELECT(x4, Cons(x0, Cons(x1, Cons(x2, x3))), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3)))), z3)) SELECT(x2, Cons(x0, Cons(x1, Nil)), Cons(z2, z3)) -> c1(SELECT(z2, Cons(x2, Cons(x0, Cons(x1, Nil))), z3)) SELECT(x2, Cons(x0, x1), Cons(x3, Cons(x4, x5))) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Cons(x4, x5))) SELECT(x2, Cons(x0, x1), Cons(x3, Nil)) -> c1(SELECT(x3, Cons(x2, Cons(x0, x1)), Nil)) SELECT(z0, Cons(z1, z2), Cons(z3, Cons(z4, z5))) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Cons(z4, z5))))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Cons(z4, z5)))), select(z4, Cons(z3, Cons(z0, Cons(z1, z2))), z5))), SELECT(z3, Cons(z0, Cons(z1, z2)), Cons(z4, z5))) SELECT(z0, Cons(z1, z2), Cons(z3, Nil)) -> c1(MAPCONSAPP(z0, permute(revapp(z2, Cons(z1, Cons(z3, Nil)))), mapconsapp(z3, permute(revapp(Cons(z1, z2), Cons(z0, Nil))), Nil)), SELECT(z3, Cons(z0, Cons(z1, z2)), Nil)) SELECT(z0, Cons(z1, Nil), Cons(z2, z3)) -> c1(MAPCONSAPP(z0, select(z1, Nil, Cons(z2, z3)), select(z2, Cons(z0, Cons(z1, Nil)), z3)), SELECT(z2, Cons(z0, Cons(z1, Nil)), z3)) K tuples: PERMUTE(Cons(z0, z1)) -> c5(SELECT(z0, Nil, z1)) SELECT(x0, Nil, Cons(x2, Cons(x3, x4))) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Cons(x3, x4))), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Cons(x3, x4))), select(x3, Cons(x2, Cons(x0, Nil)), x4))), SELECT(x2, Cons(x0, Nil), Cons(x3, x4))) SELECT(x0, Nil, Cons(x2, Nil)) -> c1(MAPCONSAPP(x0, permute(Cons(x2, Nil)), mapconsapp(x2, permute(revapp(Cons(x0, Nil), Nil)), Nil)), SELECT(x2, Cons(x0, Nil), Nil)) SELECT(x0, Nil, Cons(z2, z3)) -> c1(SELECT(z2, Cons(x0, Nil), z3)) Defined Rule Symbols: permute_1, revapp_2, select_3, mapconsapp_3 Defined Pair Symbols: PERMUTE_1, MAPCONSAPP_3, SELECT_3, REVAPP_2 Compound Symbols: c5_1, c7_1, c1_2, c1_1, c2_3, c2_2, c2_1, c_3, c_2, c3_1, c_1