KILLED proof of input_PuLVn2bF79.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) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms] (6) CpxWeightedTrs (7) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms] (8) CpxTypedWeightedTrs (9) CompletionProof [UPPER BOUND(ID), 0 ms] (10) CpxTypedWeightedCompleteTrs (11) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (12) CpxTypedWeightedCompleteTrs (13) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 6 ms] (14) CpxRNTS (15) SimplificationProof [BOTH BOUNDS(ID, ID), 4 ms] (16) CpxRNTS (17) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 2 ms] (18) CpxRNTS (19) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (20) CpxRNTS (21) IntTrsBoundProof [UPPER BOUND(ID), 424 ms] (22) CpxRNTS (23) IntTrsBoundProof [UPPER BOUND(ID), 162 ms] (24) CpxRNTS (25) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (26) CpxRNTS (27) IntTrsBoundProof [UPPER BOUND(ID), 285 ms] (28) CpxRNTS (29) IntTrsBoundProof [UPPER BOUND(ID), 77 ms] (30) CpxRNTS (31) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (32) CpxRNTS (33) IntTrsBoundProof [UPPER BOUND(ID), 221 ms] (34) CpxRNTS (35) IntTrsBoundProof [UPPER BOUND(ID), 5 ms] (36) CpxRNTS (37) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (38) CpxRNTS (39) IntTrsBoundProof [UPPER BOUND(ID), 108 ms] (40) CpxRNTS (41) IntTrsBoundProof [UPPER BOUND(ID), 3 ms] (42) CpxRNTS (43) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (44) CpxRNTS (45) IntTrsBoundProof [UPPER BOUND(ID), 271 ms] (46) CpxRNTS (47) IntTrsBoundProof [UPPER BOUND(ID), 24 ms] (48) CpxRNTS (49) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (50) CpxRNTS (51) IntTrsBoundProof [UPPER BOUND(ID), 87 ms] (52) CpxRNTS (53) IntTrsBoundProof [UPPER BOUND(ID), 2 ms] (54) CpxRNTS (55) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (56) CpxRNTS (57) IntTrsBoundProof [UPPER BOUND(ID), 4726 ms] (58) CpxRNTS (59) IntTrsBoundProof [UPPER BOUND(ID), 1231 ms] (60) CpxRNTS (61) CompletionProof [UPPER BOUND(ID), 0 ms] (62) CpxTypedWeightedCompleteTrs (63) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 2 ms] (64) CpxRNTS (65) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms] (66) CdtProblem (67) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (68) CdtProblem (69) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (70) CdtProblem (71) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (72) CdtProblem (73) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (74) CdtProblem (75) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (76) CdtProblem (77) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (78) CdtProblem (79) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (80) CdtProblem (81) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (82) CdtProblem (83) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (84) CdtProblem (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (86) CdtProblem (87) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (88) CdtProblem (89) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (90) CdtProblem (91) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (92) CdtProblem (93) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (94) CdtProblem (95) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (96) CdtProblem (97) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (98) CdtProblem (99) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (100) CdtProblem (101) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (102) CdtProblem (103) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (104) CdtProblem (105) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (106) CdtProblem (107) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (108) CdtProblem (109) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (110) CdtProblem (111) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (112) CdtProblem (113) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (114) CdtProblem (115) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (116) CdtProblem (117) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (118) CdtProblem (119) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (120) CdtProblem (121) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (122) CdtProblem (123) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (124) CdtProblem (125) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 50 ms] (126) CdtProblem (127) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 1 ms] (128) CdtProblem (129) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (130) CdtProblem (131) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 87 ms] (132) CdtProblem (133) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (134) CdtProblem (135) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (136) CdtProblem (137) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (138) CdtProblem (139) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (140) CdtProblem (141) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (142) CdtProblem (143) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (144) CdtProblem (145) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (146) CdtProblem (147) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (148) CdtProblem (149) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 77 ms] (150) CdtProblem (151) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (152) CdtProblem (153) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (154) CdtProblem (155) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (156) CdtProblem (157) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (158) CdtProblem (159) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (160) CdtProblem (161) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (162) CdtProblem (163) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (164) CdtProblem (165) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 123 ms] (166) CdtProblem (167) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (168) CdtProblem (169) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (170) CdtProblem (171) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (172) CdtProblem (173) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (174) CdtProblem (175) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (176) CdtProblem (177) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (178) CdtProblem (179) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (180) CdtProblem (181) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 108 ms] (182) CdtProblem (183) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (184) CdtProblem (185) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (186) CdtProblem (187) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (188) CdtProblem (189) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (190) CdtProblem (191) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (192) CdtProblem (193) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (194) CdtProblem (195) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (196) CdtProblem (197) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 131 ms] (198) CdtProblem (199) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (200) CdtProblem (201) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 197 ms] (202) CdtProblem (203) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (204) CdtProblem (205) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (206) CdtProblem (207) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (208) CdtProblem (209) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (210) CdtProblem (211) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 179 ms] (212) CdtProblem (213) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (214) CdtProblem (215) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (216) CdtProblem (217) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (218) CdtProblem (219) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (220) CdtProblem (221) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (222) CdtProblem (223) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (224) CdtProblem (225) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (226) CdtProblem (227) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (228) CdtProblem (229) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 176 ms] (230) CdtProblem (231) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (232) CdtProblem (233) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (234) CdtProblem (235) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 209 ms] (236) CdtProblem (237) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (238) CdtProblem (239) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (240) CdtProblem (241) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 1 ms] (242) CdtProblem (243) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (244) CdtProblem (245) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (246) CdtProblem (247) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 169 ms] (248) CdtProblem (249) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (250) CdtProblem (251) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (252) 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: le(s(x), 0) -> false le(0, y) -> true le(s(x), s(y)) -> le(x, y) double(0) -> 0 double(s(x)) -> s(s(double(x))) log(0) -> logError log(s(x)) -> loop(s(x), s(0), 0) loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z) if(true, x, y, z) -> z if(false, x, y, z) -> loop(x, double(y), s(z)) maplog(xs) -> mapIter(xs, nil) mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys) ifmap(true, xs, ys) -> ys ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys)) isempty(nil) -> true isempty(cons(x, xs)) -> false last(nil) -> error last(cons(x, nil)) -> x last(cons(x, cons(y, xs))) -> last(cons(y, xs)) droplast(nil) -> nil droplast(cons(x, nil)) -> nil droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) a -> b a -> c 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: le(s(x), 0') -> false le(0', y) -> true le(s(x), s(y)) -> le(x, y) double(0') -> 0' double(s(x)) -> s(s(double(x))) log(0') -> logError log(s(x)) -> loop(s(x), s(0'), 0') loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z) if(true, x, y, z) -> z if(false, x, y, z) -> loop(x, double(y), s(z)) maplog(xs) -> mapIter(xs, nil) mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys) ifmap(true, xs, ys) -> ys ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys)) isempty(nil) -> true isempty(cons(x, xs)) -> false last(nil) -> error last(cons(x, nil)) -> x last(cons(x, cons(y, xs))) -> last(cons(y, xs)) droplast(nil) -> nil droplast(cons(x, nil)) -> nil droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) a -> b a -> c 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: le(s(x), 0) -> false le(0, y) -> true le(s(x), s(y)) -> le(x, y) double(0) -> 0 double(s(x)) -> s(s(double(x))) log(0) -> logError log(s(x)) -> loop(s(x), s(0), 0) loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z) if(true, x, y, z) -> z if(false, x, y, z) -> loop(x, double(y), s(z)) maplog(xs) -> mapIter(xs, nil) mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys) ifmap(true, xs, ys) -> ys ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys)) isempty(nil) -> true isempty(cons(x, xs)) -> false last(nil) -> error last(cons(x, nil)) -> x last(cons(x, cons(y, xs))) -> last(cons(y, xs)) droplast(nil) -> nil droplast(cons(x, nil)) -> nil droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) a -> b a -> c S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (5) RelTrsToWeightedTrsProof (UPPER BOUND(ID)) Transformed relative TRS to weighted TRS ---------------------------------------- (6) 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: le(s(x), 0) -> false [1] le(0, y) -> true [1] le(s(x), s(y)) -> le(x, y) [1] double(0) -> 0 [1] double(s(x)) -> s(s(double(x))) [1] log(0) -> logError [1] log(s(x)) -> loop(s(x), s(0), 0) [1] loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z) [1] if(true, x, y, z) -> z [1] if(false, x, y, z) -> loop(x, double(y), s(z)) [1] maplog(xs) -> mapIter(xs, nil) [1] mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys) [1] ifmap(true, xs, ys) -> ys [1] ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys)) [1] isempty(nil) -> true [1] isempty(cons(x, xs)) -> false [1] last(nil) -> error [1] last(cons(x, nil)) -> x [1] last(cons(x, cons(y, xs))) -> last(cons(y, xs)) [1] droplast(nil) -> nil [1] droplast(cons(x, nil)) -> nil [1] droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) [1] a -> b [1] a -> c [1] Rewrite Strategy: INNERMOST ---------------------------------------- (7) TypeInferenceProof (BOTH BOUNDS(ID, ID)) Infered types. ---------------------------------------- (8) Obligation: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: le(s(x), 0) -> false [1] le(0, y) -> true [1] le(s(x), s(y)) -> le(x, y) [1] double(0) -> 0 [1] double(s(x)) -> s(s(double(x))) [1] log(0) -> logError [1] log(s(x)) -> loop(s(x), s(0), 0) [1] loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z) [1] if(true, x, y, z) -> z [1] if(false, x, y, z) -> loop(x, double(y), s(z)) [1] maplog(xs) -> mapIter(xs, nil) [1] mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys) [1] ifmap(true, xs, ys) -> ys [1] ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys)) [1] isempty(nil) -> true [1] isempty(cons(x, xs)) -> false [1] last(nil) -> error [1] last(cons(x, nil)) -> x [1] last(cons(x, cons(y, xs))) -> last(cons(y, xs)) [1] droplast(nil) -> nil [1] droplast(cons(x, nil)) -> nil [1] droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) [1] a -> b [1] a -> c [1] The TRS has the following type information: le :: s:0:logError:error -> s:0:logError:error -> false:true s :: s:0:logError:error -> s:0:logError:error 0 :: s:0:logError:error false :: false:true true :: false:true double :: s:0:logError:error -> s:0:logError:error log :: s:0:logError:error -> s:0:logError:error logError :: s:0:logError:error loop :: s:0:logError:error -> s:0:logError:error -> s:0:logError:error -> s:0:logError:error if :: false:true -> s:0:logError:error -> s:0:logError:error -> s:0:logError:error -> s:0:logError:error maplog :: nil:cons -> nil:cons mapIter :: nil:cons -> nil:cons -> nil:cons nil :: nil:cons ifmap :: false:true -> nil:cons -> nil:cons -> nil:cons isempty :: nil:cons -> false:true droplast :: nil:cons -> nil:cons cons :: s:0:logError:error -> nil:cons -> nil:cons last :: nil:cons -> s:0:logError:error error :: s:0:logError:error a :: b:c b :: b:c c :: b:c Rewrite Strategy: INNERMOST ---------------------------------------- (9) 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: maplog_1 mapIter_2 ifmap_3 a (c) The following functions are completely defined: droplast_1 log_1 last_1 le_2 double_1 isempty_1 loop_3 if_4 Due to the following rules being added: log(v0) -> null_log [0] le(v0, v1) -> null_le [0] double(v0) -> null_double [0] loop(v0, v1, v2) -> null_loop [0] if(v0, v1, v2, v3) -> null_if [0] And the following fresh constants: null_log, null_le, null_double, null_loop, null_if ---------------------------------------- (10) 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: le(s(x), 0) -> false [1] le(0, y) -> true [1] le(s(x), s(y)) -> le(x, y) [1] double(0) -> 0 [1] double(s(x)) -> s(s(double(x))) [1] log(0) -> logError [1] log(s(x)) -> loop(s(x), s(0), 0) [1] loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z) [1] if(true, x, y, z) -> z [1] if(false, x, y, z) -> loop(x, double(y), s(z)) [1] maplog(xs) -> mapIter(xs, nil) [1] mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys) [1] ifmap(true, xs, ys) -> ys [1] ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys)) [1] isempty(nil) -> true [1] isempty(cons(x, xs)) -> false [1] last(nil) -> error [1] last(cons(x, nil)) -> x [1] last(cons(x, cons(y, xs))) -> last(cons(y, xs)) [1] droplast(nil) -> nil [1] droplast(cons(x, nil)) -> nil [1] droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) [1] a -> b [1] a -> c [1] log(v0) -> null_log [0] le(v0, v1) -> null_le [0] double(v0) -> null_double [0] loop(v0, v1, v2) -> null_loop [0] if(v0, v1, v2, v3) -> null_if [0] The TRS has the following type information: le :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> false:true:null_le s :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if 0 :: s:0:logError:error:null_log:null_double:null_loop:null_if false :: false:true:null_le true :: false:true:null_le double :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if log :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if logError :: s:0:logError:error:null_log:null_double:null_loop:null_if loop :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if if :: false:true:null_le -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if maplog :: nil:cons -> nil:cons mapIter :: nil:cons -> nil:cons -> nil:cons nil :: nil:cons ifmap :: false:true:null_le -> nil:cons -> nil:cons -> nil:cons isempty :: nil:cons -> false:true:null_le droplast :: nil:cons -> nil:cons cons :: s:0:logError:error:null_log:null_double:null_loop:null_if -> nil:cons -> nil:cons last :: nil:cons -> s:0:logError:error:null_log:null_double:null_loop:null_if error :: s:0:logError:error:null_log:null_double:null_loop:null_if a :: b:c b :: b:c c :: b:c null_log :: s:0:logError:error:null_log:null_double:null_loop:null_if null_le :: false:true:null_le null_double :: s:0:logError:error:null_log:null_double:null_loop:null_if null_loop :: s:0:logError:error:null_log:null_double:null_loop:null_if null_if :: s:0:logError:error:null_log:null_double:null_loop:null_if Rewrite Strategy: INNERMOST ---------------------------------------- (11) NarrowingProof (BOTH BOUNDS(ID, ID)) Narrowed the inner basic terms of all right-hand sides by a single narrowing step. ---------------------------------------- (12) 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: le(s(x), 0) -> false [1] le(0, y) -> true [1] le(s(x), s(y)) -> le(x, y) [1] double(0) -> 0 [1] double(s(x)) -> s(s(double(x))) [1] log(0) -> logError [1] log(s(x)) -> loop(s(x), s(0), 0) [1] loop(0, s(y), z) -> if(true, 0, s(y), z) [2] loop(s(x'), s(y), z) -> if(le(x', y), s(x'), s(y), z) [2] loop(x, s(y), z) -> if(null_le, x, s(y), z) [1] if(true, x, y, z) -> z [1] if(false, x, 0, z) -> loop(x, 0, s(z)) [2] if(false, x, s(x''), z) -> loop(x, s(s(double(x''))), s(z)) [2] if(false, x, y, z) -> loop(x, null_double, s(z)) [1] maplog(xs) -> mapIter(xs, nil) [1] mapIter(nil, ys) -> ifmap(true, nil, ys) [2] mapIter(cons(x1, xs'), ys) -> ifmap(false, cons(x1, xs'), ys) [2] ifmap(true, xs, ys) -> ys [1] ifmap(false, nil, ys) -> mapIter(nil, cons(log(error), ys)) [3] ifmap(false, cons(x2, nil), ys) -> mapIter(nil, cons(log(x2), ys)) [3] ifmap(false, cons(x3, cons(y', xs'')), ys) -> mapIter(cons(x3, droplast(cons(y', xs''))), cons(log(last(cons(y', xs''))), ys)) [3] isempty(nil) -> true [1] isempty(cons(x, xs)) -> false [1] last(nil) -> error [1] last(cons(x, nil)) -> x [1] last(cons(x, cons(y, xs))) -> last(cons(y, xs)) [1] droplast(nil) -> nil [1] droplast(cons(x, nil)) -> nil [1] droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) [1] a -> b [1] a -> c [1] log(v0) -> null_log [0] le(v0, v1) -> null_le [0] double(v0) -> null_double [0] loop(v0, v1, v2) -> null_loop [0] if(v0, v1, v2, v3) -> null_if [0] The TRS has the following type information: le :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> false:true:null_le s :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if 0 :: s:0:logError:error:null_log:null_double:null_loop:null_if false :: false:true:null_le true :: false:true:null_le double :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if log :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if logError :: s:0:logError:error:null_log:null_double:null_loop:null_if loop :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if if :: false:true:null_le -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if maplog :: nil:cons -> nil:cons mapIter :: nil:cons -> nil:cons -> nil:cons nil :: nil:cons ifmap :: false:true:null_le -> nil:cons -> nil:cons -> nil:cons isempty :: nil:cons -> false:true:null_le droplast :: nil:cons -> nil:cons cons :: s:0:logError:error:null_log:null_double:null_loop:null_if -> nil:cons -> nil:cons last :: nil:cons -> s:0:logError:error:null_log:null_double:null_loop:null_if error :: s:0:logError:error:null_log:null_double:null_loop:null_if a :: b:c b :: b:c c :: b:c null_log :: s:0:logError:error:null_log:null_double:null_loop:null_if null_le :: false:true:null_le null_double :: s:0:logError:error:null_log:null_double:null_loop:null_if null_loop :: s:0:logError:error:null_log:null_double:null_loop:null_if null_if :: s:0:logError:error:null_log:null_double:null_loop:null_if Rewrite Strategy: INNERMOST ---------------------------------------- (13) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID)) Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction. The constant constructors are abstracted as follows: 0 => 0 false => 1 true => 2 logError => 2 nil => 0 error => 1 b => 0 c => 1 null_log => 0 null_le => 0 null_double => 0 null_loop => 0 null_if => 0 ---------------------------------------- (14) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0 double(z') -{ 1 }-> 1 + (1 + double(x)) :|: z' = 1 + x, x >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: x >= 0, z' = 1 + x + 0 droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z :|: z1 = y, z >= 0, z' = 2, z2 = z, x >= 0, y >= 0, z'' = x if(z', z'', z1, z2) -{ 2 }-> loop(x, 0, 1 + z) :|: z1 = 0, z >= 0, z2 = z, x >= 0, z'' = x, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(x, 0, 1 + z) :|: z1 = y, z >= 0, z2 = z, x >= 0, y >= 0, z'' = x, z' = 1 if(z', z'', z1, z2) -{ 2 }-> loop(x, 1 + (1 + double(x'')), 1 + z) :|: z >= 0, z1 = 1 + x'', z2 = z, x >= 0, z'' = x, z' = 1, x'' >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z2 = v3, v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, v3 >= 0, z' = v0 ifmap(z', z'', z1) -{ 1 }-> ys :|: xs >= 0, z' = 2, ys >= 0, z'' = xs, z1 = ys ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(x2) + ys) :|: z'' = 1 + x2 + 0, ys >= 0, z' = 1, x2 >= 0, z1 = ys ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + ys) :|: z'' = 0, ys >= 0, z' = 1, z1 = ys ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + ys) :|: ys >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0, z1 = ys isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> x :|: x >= 0, z' = 1 + x + 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 le(z', z'') -{ 1 }-> le(x, y) :|: z' = 1 + x, x >= 0, y >= 0, z'' = 1 + y le(z', z'') -{ 1 }-> 2 :|: z'' = y, y >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 1 + x, x >= 0 le(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0 log(z') -{ 1 }-> loop(1 + x, 1 + 0, 0) :|: z' = 1 + x, x >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0 loop(z', z'', z1) -{ 2 }-> if(le(x', y), 1 + x', 1 + y, z) :|: z1 = z, z >= 0, z' = 1 + x', x' >= 0, y >= 0, z'' = 1 + y loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + y, z) :|: z1 = z, z >= 0, y >= 0, z'' = 1 + y, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, x, 1 + y, z) :|: z1 = z, z >= 0, z' = x, x >= 0, y >= 0, z'' = 1 + y loop(z', z'', z1) -{ 0 }-> 0 :|: v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, z' = v0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, ys) :|: ys >= 0, z'' = ys, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', ys) :|: x1 >= 0, z' = 1 + x1 + xs', ys >= 0, xs' >= 0, z'' = ys maplog(z') -{ 1 }-> mapIter(xs, 0) :|: xs >= 0, z' = xs ---------------------------------------- (15) SimplificationProof (BOTH BOUNDS(ID, ID)) Simplified the RNTS by moving equalities from the constraints into the right-hand sides. ---------------------------------------- (16) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 2 }-> if(le(z' - 1, z'' - 1), 1 + (z' - 1), 1 + (z'' - 1), z1) :|: z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 ---------------------------------------- (17) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID)) Found the following analysis order by SCC decomposition: { le } { droplast } { double } { isempty } { last } { a } { if, loop } { log } { ifmap, mapIter } { maplog } ---------------------------------------- (18) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 2 }-> if(le(z' - 1, z'' - 1), 1 + (z' - 1), 1 + (z'' - 1), z1) :|: z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {le}, {droplast}, {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} ---------------------------------------- (19) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (20) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 2 }-> if(le(z' - 1, z'' - 1), 1 + (z' - 1), 1 + (z'' - 1), z1) :|: z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {le}, {droplast}, {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} ---------------------------------------- (21) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: le after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 2 ---------------------------------------- (22) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 2 }-> if(le(z' - 1, z'' - 1), 1 + (z' - 1), 1 + (z'' - 1), z1) :|: z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {le}, {droplast}, {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: ?, size: O(1) [2] ---------------------------------------- (23) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using KoAT for: le after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 2 + z'' ---------------------------------------- (24) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 2 }-> if(le(z' - 1, z'' - 1), 1 + (z' - 1), 1 + (z'' - 1), z1) :|: z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {droplast}, {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] ---------------------------------------- (25) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (26) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {droplast}, {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] ---------------------------------------- (27) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: droplast after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z' ---------------------------------------- (28) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {droplast}, {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: ?, size: O(n^1) [z'] ---------------------------------------- (29) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: droplast after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 2 + z' ---------------------------------------- (30) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] ---------------------------------------- (31) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (32) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] ---------------------------------------- (33) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: double after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 2*z' ---------------------------------------- (34) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: ?, size: O(n^1) [2*z'] ---------------------------------------- (35) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: double after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z' ---------------------------------------- (36) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] ---------------------------------------- (37) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (38) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] ---------------------------------------- (39) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: isempty after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 2 ---------------------------------------- (40) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] isempty: runtime: ?, size: O(1) [2] ---------------------------------------- (41) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: isempty after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (42) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] isempty: runtime: O(1) [1], size: O(1) [2] ---------------------------------------- (43) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (44) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] isempty: runtime: O(1) [1], size: O(1) [2] ---------------------------------------- (45) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: last after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z' ---------------------------------------- (46) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] isempty: runtime: O(1) [1], size: O(1) [2] last: runtime: ?, size: O(n^1) [1 + z'] ---------------------------------------- (47) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: last after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 2 + z' ---------------------------------------- (48) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] isempty: runtime: O(1) [1], size: O(1) [2] last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z'] ---------------------------------------- (49) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (50) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 9 + 2*xs'' + 2*y' }-> mapIter(1 + x3 + s'', 1 + log(s4) + z1) :|: s4 >= 0, s4 <= 1 + y' + xs'' + 1, s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 4 + xs + y }-> s5 :|: s5 >= 0, s5 <= 1 + y + xs + 1, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] isempty: runtime: O(1) [1], size: O(1) [2] last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z'] ---------------------------------------- (51) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: a after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (52) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 9 + 2*xs'' + 2*y' }-> mapIter(1 + x3 + s'', 1 + log(s4) + z1) :|: s4 >= 0, s4 <= 1 + y' + xs'' + 1, s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 4 + xs + y }-> s5 :|: s5 >= 0, s5 <= 1 + y + xs + 1, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] isempty: runtime: O(1) [1], size: O(1) [2] last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z'] a: runtime: ?, size: O(1) [1] ---------------------------------------- (53) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: a after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (54) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 9 + 2*xs'' + 2*y' }-> mapIter(1 + x3 + s'', 1 + log(s4) + z1) :|: s4 >= 0, s4 <= 1 + y' + xs'' + 1, s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 4 + xs + y }-> s5 :|: s5 >= 0, s5 <= 1 + y + xs + 1, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] isempty: runtime: O(1) [1], size: O(1) [2] last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z'] a: runtime: O(1) [1], size: O(1) [1] ---------------------------------------- (55) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (56) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 9 + 2*xs'' + 2*y' }-> mapIter(1 + x3 + s'', 1 + log(s4) + z1) :|: s4 >= 0, s4 <= 1 + y' + xs'' + 1, s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 4 + xs + y }-> s5 :|: s5 >= 0, s5 <= 1 + y + xs + 1, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] isempty: runtime: O(1) [1], size: O(1) [2] last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z'] a: runtime: O(1) [1], size: O(1) [1] ---------------------------------------- (57) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: if after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? Computed SIZE bound using CoFloCo for: loop after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (58) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 9 + 2*xs'' + 2*y' }-> mapIter(1 + x3 + s'', 1 + log(s4) + z1) :|: s4 >= 0, s4 <= 1 + y' + xs'' + 1, s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 4 + xs + y }-> s5 :|: s5 >= 0, s5 <= 1 + y + xs + 1, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] isempty: runtime: O(1) [1], size: O(1) [2] last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z'] a: runtime: O(1) [1], size: O(1) [1] if: runtime: ?, size: INF loop: runtime: ?, size: INF ---------------------------------------- (59) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: if after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (60) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: z' >= 0 double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0 droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1 if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1 ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0 ifmap(z', z'', z1) -{ 9 + 2*xs'' + 2*y' }-> mapIter(1 + x3 + s'', 1 + log(s4) + z1) :|: s4 >= 0, s4 <= 1 + y' + xs'' + 1, s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 last(z') -{ 4 + xs + y }-> s5 :|: s5 >= 0, s5 <= 1 + y + xs + 1, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0 le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: z' >= 0 loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0 loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0 loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0 mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0 mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0 maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0 Function symbols to be analyzed: {if,loop}, {log}, {ifmap,mapIter}, {maplog} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z'] double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z'] isempty: runtime: O(1) [1], size: O(1) [2] last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z'] a: runtime: O(1) [1], size: O(1) [1] if: runtime: INF, size: INF loop: runtime: ?, size: INF ---------------------------------------- (61) 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: le(v0, v1) -> null_le [0] double(v0) -> null_double [0] log(v0) -> null_log [0] loop(v0, v1, v2) -> null_loop [0] if(v0, v1, v2, v3) -> null_if [0] ifmap(v0, v1, v2) -> null_ifmap [0] isempty(v0) -> null_isempty [0] last(v0) -> null_last [0] droplast(v0) -> null_droplast [0] And the following fresh constants: null_le, null_double, null_log, null_loop, null_if, null_ifmap, null_isempty, null_last, null_droplast ---------------------------------------- (62) 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: le(s(x), 0) -> false [1] le(0, y) -> true [1] le(s(x), s(y)) -> le(x, y) [1] double(0) -> 0 [1] double(s(x)) -> s(s(double(x))) [1] log(0) -> logError [1] log(s(x)) -> loop(s(x), s(0), 0) [1] loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z) [1] if(true, x, y, z) -> z [1] if(false, x, y, z) -> loop(x, double(y), s(z)) [1] maplog(xs) -> mapIter(xs, nil) [1] mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys) [1] ifmap(true, xs, ys) -> ys [1] ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys)) [1] isempty(nil) -> true [1] isempty(cons(x, xs)) -> false [1] last(nil) -> error [1] last(cons(x, nil)) -> x [1] last(cons(x, cons(y, xs))) -> last(cons(y, xs)) [1] droplast(nil) -> nil [1] droplast(cons(x, nil)) -> nil [1] droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) [1] a -> b [1] a -> c [1] le(v0, v1) -> null_le [0] double(v0) -> null_double [0] log(v0) -> null_log [0] loop(v0, v1, v2) -> null_loop [0] if(v0, v1, v2, v3) -> null_if [0] ifmap(v0, v1, v2) -> null_ifmap [0] isempty(v0) -> null_isempty [0] last(v0) -> null_last [0] droplast(v0) -> null_droplast [0] The TRS has the following type information: le :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> false:true:null_le:null_isempty s :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last 0 :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last false :: false:true:null_le:null_isempty true :: false:true:null_le:null_isempty double :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last log :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last logError :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last loop :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last if :: false:true:null_le:null_isempty -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last maplog :: nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast mapIter :: nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast nil :: nil:cons:null_ifmap:null_droplast ifmap :: false:true:null_le:null_isempty -> nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast isempty :: nil:cons:null_ifmap:null_droplast -> false:true:null_le:null_isempty droplast :: nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast cons :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast last :: nil:cons:null_ifmap:null_droplast -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last error :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last a :: b:c b :: b:c c :: b:c null_le :: false:true:null_le:null_isempty null_double :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last null_log :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last null_loop :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last null_if :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last null_ifmap :: nil:cons:null_ifmap:null_droplast null_isempty :: false:true:null_le:null_isempty null_last :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last null_droplast :: nil:cons:null_ifmap:null_droplast Rewrite Strategy: INNERMOST ---------------------------------------- (63) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID)) Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction. The constant constructors are abstracted as follows: 0 => 0 false => 1 true => 2 logError => 2 nil => 0 error => 1 b => 0 c => 1 null_le => 0 null_double => 0 null_log => 0 null_loop => 0 null_if => 0 null_ifmap => 0 null_isempty => 0 null_last => 0 null_droplast => 0 ---------------------------------------- (64) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: double(z') -{ 1 }-> 0 :|: z' = 0 double(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0 double(z') -{ 1 }-> 1 + (1 + double(x)) :|: z' = 1 + x, x >= 0 droplast(z') -{ 1 }-> 0 :|: z' = 0 droplast(z') -{ 1 }-> 0 :|: x >= 0, z' = 1 + x + 0 droplast(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0 droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 if(z', z'', z1, z2) -{ 1 }-> z :|: z1 = y, z >= 0, z' = 2, z2 = z, x >= 0, y >= 0, z'' = x if(z', z'', z1, z2) -{ 1 }-> loop(x, double(y), 1 + z) :|: z1 = y, z >= 0, z2 = z, x >= 0, y >= 0, z'' = x, z' = 1 if(z', z'', z1, z2) -{ 0 }-> 0 :|: z2 = v3, v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, v3 >= 0, z' = v0 ifmap(z', z'', z1) -{ 1 }-> ys :|: xs >= 0, z' = 2, ys >= 0, z'' = xs, z1 = ys ifmap(z', z'', z1) -{ 1 }-> mapIter(droplast(xs), 1 + log(last(xs)) + ys) :|: xs >= 0, ys >= 0, z'' = xs, z' = 1, z1 = ys ifmap(z', z'', z1) -{ 0 }-> 0 :|: v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, z' = v0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 isempty(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0 last(z') -{ 1 }-> x :|: x >= 0, z' = 1 + x + 0 last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0 last(z') -{ 1 }-> 1 :|: z' = 0 last(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0 le(z', z'') -{ 1 }-> le(x, y) :|: z' = 1 + x, x >= 0, y >= 0, z'' = 1 + y le(z', z'') -{ 1 }-> 2 :|: z'' = y, y >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 1 + x, x >= 0 le(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0 log(z') -{ 1 }-> loop(1 + x, 1 + 0, 0) :|: z' = 1 + x, x >= 0 log(z') -{ 1 }-> 2 :|: z' = 0 log(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0 loop(z', z'', z1) -{ 1 }-> if(le(x, 1 + y), x, 1 + y, z) :|: z1 = z, z >= 0, z' = x, x >= 0, y >= 0, z'' = 1 + y loop(z', z'', z1) -{ 0 }-> 0 :|: v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, z' = v0 mapIter(z', z'') -{ 1 }-> ifmap(isempty(xs), xs, ys) :|: xs >= 0, ys >= 0, z'' = ys, z' = xs maplog(z') -{ 1 }-> mapIter(xs, 0) :|: xs >= 0, z' = xs Only complete derivations are relevant for the runtime complexity. ---------------------------------------- (65) CpxTrsToCdtProof (UPPER BOUND(ID)) Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT ---------------------------------------- (66) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) double(0) -> 0 double(s(z0)) -> s(s(double(z0))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) maplog(z0) -> mapIter(z0, nil) mapIter(z0, z1) -> ifmap(isempty(z0), z0, z1) ifmap(true, z0, z1) -> z1 ifmap(false, z0, z1) -> mapIter(droplast(z0), cons(log(last(z0)), z1)) isempty(nil) -> true isempty(cons(z0, z1)) -> false last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) a -> b a -> c Tuples: LE(s(z0), 0) -> c1 LE(0, z0) -> c2 LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(0) -> c4 DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(0) -> c6 LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1))) IF(true, z0, z1, z2) -> c9 IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) MAPLOG(z0) -> c11(MAPITER(z0, nil)) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1), ISEMPTY(z0)) IFMAP(true, z0, z1) -> c13 IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) ISEMPTY(nil) -> c16 ISEMPTY(cons(z0, z1)) -> c17 LAST(nil) -> c18 LAST(cons(z0, nil)) -> c19 LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(nil) -> c21 DROPLAST(cons(z0, nil)) -> c22 DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) A -> c24 A -> c25 S tuples: LE(s(z0), 0) -> c1 LE(0, z0) -> c2 LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(0) -> c4 DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(0) -> c6 LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1))) IF(true, z0, z1, z2) -> c9 IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) MAPLOG(z0) -> c11(MAPITER(z0, nil)) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1), ISEMPTY(z0)) IFMAP(true, z0, z1) -> c13 IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) ISEMPTY(nil) -> c16 ISEMPTY(cons(z0, z1)) -> c17 LAST(nil) -> c18 LAST(cons(z0, nil)) -> c19 LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(nil) -> c21 DROPLAST(cons(z0, nil)) -> c22 DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) A -> c24 A -> c25 K tuples:none Defined Rule Symbols: le_2, double_1, log_1, loop_3, if_4, maplog_1, mapIter_2, ifmap_3, isempty_1, last_1, droplast_1, a Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LOOP_3, IF_4, MAPLOG_1, MAPITER_2, IFMAP_3, ISEMPTY_1, LAST_1, DROPLAST_1, A Compound Symbols: c1, c2, c3_1, c4, c5_1, c6, c7_1, c8_2, c9, c10_2, c11_1, c12_2, c13, c14_2, c15_3, c16, c17, c18, c19, c20_1, c21, c22, c23_1, c24, c25 ---------------------------------------- (67) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: MAPLOG(z0) -> c11(MAPITER(z0, nil)) Removed 14 trailing nodes: IF(true, z0, z1, z2) -> c9 ISEMPTY(nil) -> c16 DOUBLE(0) -> c4 A -> c25 ISEMPTY(cons(z0, z1)) -> c17 LE(s(z0), 0) -> c1 DROPLAST(cons(z0, nil)) -> c22 LAST(nil) -> c18 LOG(0) -> c6 IFMAP(true, z0, z1) -> c13 DROPLAST(nil) -> c21 LE(0, z0) -> c2 A -> c24 LAST(cons(z0, nil)) -> c19 ---------------------------------------- (68) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) double(0) -> 0 double(s(z0)) -> s(s(double(z0))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) maplog(z0) -> mapIter(z0, nil) mapIter(z0, z1) -> ifmap(isempty(z0), z0, z1) ifmap(true, z0, z1) -> z1 ifmap(false, z0, z1) -> mapIter(droplast(z0), cons(log(last(z0)), z1)) isempty(nil) -> true isempty(cons(z0, z1)) -> false last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) a -> b a -> c Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1))) IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1), ISEMPTY(z0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1))) IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1), ISEMPTY(z0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) K tuples:none Defined Rule Symbols: le_2, double_1, log_1, loop_3, if_4, maplog_1, mapIter_2, ifmap_3, isempty_1, last_1, droplast_1, a Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LOOP_3, IF_4, MAPITER_2, IFMAP_3, LAST_1, DROPLAST_1 Compound Symbols: c3_1, c5_1, c7_1, c8_2, c10_2, c12_2, c14_2, c15_3, c20_1, c23_1 ---------------------------------------- (69) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (70) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) double(0) -> 0 double(s(z0)) -> s(s(double(z0))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) maplog(z0) -> mapIter(z0, nil) mapIter(z0, z1) -> ifmap(isempty(z0), z0, z1) ifmap(true, z0, z1) -> z1 ifmap(false, z0, z1) -> mapIter(droplast(z0), cons(log(last(z0)), z1)) isempty(nil) -> true isempty(cons(z0, z1)) -> false last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) a -> b a -> c Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1))) IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1))) IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) K tuples:none Defined Rule Symbols: le_2, double_1, log_1, loop_3, if_4, maplog_1, mapIter_2, ifmap_3, isempty_1, last_1, droplast_1, a Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LOOP_3, IF_4, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2 Compound Symbols: c3_1, c5_1, c7_1, c8_2, c10_2, c14_2, c15_3, c20_1, c23_1, c12_1 ---------------------------------------- (71) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: maplog(z0) -> mapIter(z0, nil) mapIter(z0, z1) -> ifmap(isempty(z0), z0, z1) ifmap(true, z0, z1) -> z1 ifmap(false, z0, z1) -> mapIter(droplast(z0), cons(log(last(z0)), z1)) a -> b a -> c ---------------------------------------- (72) Obligation: Complexity Dependency Tuples Problem Rules: le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) isempty(nil) -> true isempty(cons(z0, z1)) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1))) IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1))) IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) K tuples:none Defined Rule Symbols: le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LOOP_3, IF_4, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2 Compound Symbols: c3_1, c5_1, c7_1, c8_2, c10_2, c14_2, c15_3, c20_1, c23_1, c12_1 ---------------------------------------- (73) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1))) by LOOP(0, s(x1), x2) -> c8(IF(true, 0, s(x1), x2), LE(0, s(x1))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) ---------------------------------------- (74) Obligation: Complexity Dependency Tuples Problem Rules: le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) isempty(nil) -> true isempty(cons(z0, z1)) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) LOOP(0, s(x1), x2) -> c8(IF(true, 0, s(x1), x2), LE(0, s(x1))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) LOOP(0, s(x1), x2) -> c8(IF(true, 0, s(x1), x2), LE(0, s(x1))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) K tuples:none Defined Rule Symbols: le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, IF_4, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c10_2, c14_2, c15_3, c20_1, c23_1, c12_1, c8_2 ---------------------------------------- (75) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: LOOP(0, s(x1), x2) -> c8(IF(true, 0, s(x1), x2), LE(0, s(x1))) ---------------------------------------- (76) Obligation: Complexity Dependency Tuples Problem Rules: le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) isempty(nil) -> true isempty(cons(z0, z1)) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) K tuples:none Defined Rule Symbols: le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, IF_4, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c10_2, c14_2, c15_3, c20_1, c23_1, c12_1, c8_2 ---------------------------------------- (77) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) by IF(false, x0, 0, x2) -> c10(LOOP(x0, 0, s(x2)), DOUBLE(0)) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) ---------------------------------------- (78) Obligation: Complexity Dependency Tuples Problem Rules: le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) isempty(nil) -> true isempty(cons(z0, z1)) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, 0, x2) -> c10(LOOP(x0, 0, s(x2)), DOUBLE(0)) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, 0, x2) -> c10(LOOP(x0, 0, s(x2)), DOUBLE(0)) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) K tuples:none Defined Rule Symbols: le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2, LOOP_3, IF_4 Compound Symbols: c3_1, c5_1, c7_1, c14_2, c15_3, c20_1, c23_1, c12_1, c8_2, c10_2 ---------------------------------------- (79) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IF(false, x0, 0, x2) -> c10(LOOP(x0, 0, s(x2)), DOUBLE(0)) ---------------------------------------- (80) Obligation: Complexity Dependency Tuples Problem Rules: le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) isempty(nil) -> true isempty(cons(z0, z1)) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) K tuples:none Defined Rule Symbols: le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2, LOOP_3, IF_4 Compound Symbols: c3_1, c5_1, c7_1, c14_2, c15_3, c20_1, c23_1, c12_1, c8_2, c10_2 ---------------------------------------- (81) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) by IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)), LOG(error), LAST(nil)) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0), LAST(cons(z0, nil))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) ---------------------------------------- (82) Obligation: Complexity Dependency Tuples Problem Rules: le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) isempty(nil) -> true isempty(cons(z0, z1)) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)), LOG(error), LAST(nil)) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0), LAST(cons(z0, nil))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)), LOG(error), LAST(nil)) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0), LAST(cons(z0, nil))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) K tuples:none Defined Rule Symbols: le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2, LOOP_3, IF_4 Compound Symbols: c3_1, c5_1, c7_1, c14_2, c20_1, c23_1, c12_1, c8_2, c10_2, c15_3, c15_1 ---------------------------------------- (83) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 3 trailing tuple parts ---------------------------------------- (84) Obligation: Complexity Dependency Tuples Problem Rules: le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) isempty(nil) -> true isempty(cons(z0, z1)) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) K tuples:none Defined Rule Symbols: le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2, LOOP_3, IF_4 Compound Symbols: c3_1, c5_1, c7_1, c14_2, c20_1, c23_1, c12_1, c8_2, c10_2, c15_3, c15_1, c15_2 ---------------------------------------- (85) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) by MAPITER(nil, x1) -> c12(IFMAP(true, nil, x1)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) ---------------------------------------- (86) Obligation: Complexity Dependency Tuples Problem Rules: le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) isempty(nil) -> true isempty(cons(z0, z1)) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(nil, x1) -> c12(IFMAP(true, nil, x1)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(nil, x1) -> c12(IFMAP(true, nil, x1)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) K tuples:none Defined Rule Symbols: le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, LOOP_3, IF_4, MAPITER_2 Compound Symbols: c3_1, c5_1, c7_1, c14_2, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1 ---------------------------------------- (87) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: MAPITER(nil, x1) -> c12(IFMAP(true, nil, x1)) ---------------------------------------- (88) Obligation: Complexity Dependency Tuples Problem Rules: le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) isempty(nil) -> true isempty(cons(z0, z1)) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) K tuples:none Defined Rule Symbols: le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, LOOP_3, IF_4, MAPITER_2 Compound Symbols: c3_1, c5_1, c7_1, c14_2, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1 ---------------------------------------- (89) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) ---------------------------------------- (90) Obligation: Complexity Dependency Tuples Problem Rules: le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) isempty(nil) -> true isempty(cons(z0, z1)) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) Defined Rule Symbols: le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, LOOP_3, IF_4, MAPITER_2 Compound Symbols: c3_1, c5_1, c7_1, c14_2, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1 ---------------------------------------- (91) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: isempty(nil) -> true isempty(cons(z0, z1)) -> false ---------------------------------------- (92) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, LOOP_3, IF_4, MAPITER_2 Compound Symbols: c3_1, c5_1, c7_1, c14_2, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1 ---------------------------------------- (93) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) by IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)), DROPLAST(nil)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), DROPLAST(cons(z0, nil))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(nil, cons(log(last(nil)), x1)), DROPLAST(nil)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), DROPLAST(cons(z0, nil))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) ---------------------------------------- (94) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)), DROPLAST(nil)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), DROPLAST(cons(z0, nil))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(nil, cons(log(last(nil)), x1)), DROPLAST(nil)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), DROPLAST(cons(z0, nil))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)), DROPLAST(nil)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), DROPLAST(cons(z0, nil))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(nil, cons(log(last(nil)), x1)), DROPLAST(nil)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), DROPLAST(cons(z0, nil))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, LOOP_3, IF_4, IFMAP_3, MAPITER_2 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2 ---------------------------------------- (95) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing nodes: IFMAP(false, nil, x1) -> c14(MAPITER(nil, cons(log(last(nil)), x1)), DROPLAST(nil)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), DROPLAST(cons(z0, nil))) ---------------------------------------- (96) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)), DROPLAST(nil)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), DROPLAST(cons(z0, nil))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)), DROPLAST(nil)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), DROPLAST(cons(z0, nil))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, LOOP_3, IF_4, IFMAP_3, MAPITER_2 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2 ---------------------------------------- (97) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (98) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, LOOP_3, IF_4, IFMAP_3, MAPITER_2 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2, c14_1 ---------------------------------------- (99) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) ---------------------------------------- (100) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, LOOP_3, IF_4, IFMAP_3, MAPITER_2 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2, c14_1 ---------------------------------------- (101) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) by LOOP(s(0), s(z0), x2) -> c8(IF(true, s(0), s(z0), x2), LE(s(0), s(z0))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(s(z0)), s(0), x2) -> c8(IF(false, s(s(z0)), s(0), x2), LE(s(s(z0)), s(0))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) ---------------------------------------- (102) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(0), s(z0), x2) -> c8(IF(true, s(0), s(z0), x2), LE(s(0), s(z0))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(s(z0)), s(0), x2) -> c8(IF(false, s(s(z0)), s(0), x2), LE(s(s(z0)), s(0))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(0), s(z0), x2) -> c8(IF(true, s(0), s(z0), x2), LE(s(0), s(z0))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(s(z0)), s(0), x2) -> c8(IF(false, s(s(z0)), s(0), x2), LE(s(s(z0)), s(0))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1 ---------------------------------------- (103) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (104) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(s(z0)), s(0), x2) -> c8(IF(false, s(s(z0)), s(0), x2), LE(s(s(z0)), s(0))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(s(z0)), s(0), x2) -> c8(IF(false, s(s(z0)), s(0), x2), LE(s(s(z0)), s(0))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1 ---------------------------------------- (105) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (106) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1 ---------------------------------------- (107) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) by IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) ---------------------------------------- (108) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3 ---------------------------------------- (109) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) by IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(nil, cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) ---------------------------------------- (110) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(nil, cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(nil, cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3 ---------------------------------------- (111) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing nodes: IFMAP(false, nil, x1) -> c15(MAPITER(nil, cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1))) ---------------------------------------- (112) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3 ---------------------------------------- (113) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) ---------------------------------------- (114) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3 ---------------------------------------- (115) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) by IFMAP(false, nil, x0) -> c15(MAPITER(droplast(nil), cons(log(error), x0))) IFMAP(false, nil, x0) -> c15(MAPITER(nil, cons(log(last(nil)), x0))) ---------------------------------------- (116) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, nil, x0) -> c15(MAPITER(nil, cons(log(last(nil)), x0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1 ---------------------------------------- (117) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFMAP(false, nil, x0) -> c15(MAPITER(nil, cons(log(last(nil)), x0))) ---------------------------------------- (118) Obligation: Complexity Dependency Tuples Problem Rules: droplast(nil) -> nil droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(nil) -> error last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false double(0) -> 0 double(s(z0)) -> s(s(double(z0))) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) K tuples: IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1 ---------------------------------------- (119) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: last(nil) -> error ---------------------------------------- (120) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) K tuples: IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1 ---------------------------------------- (121) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) by IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), LOG(z0)) ---------------------------------------- (122) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), LOG(z0)) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), LOG(z0)) K tuples: IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2 ---------------------------------------- (123) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (124) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) K tuples: IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2 ---------------------------------------- (125) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) We considered the (Usable) Rules: droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil And the Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(DOUBLE(x_1)) = 0 POL(DROPLAST(x_1)) = 0 POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4 POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2 POL(LAST(x_1)) = 0 POL(LE(x_1, x_2)) = 0 POL(LOG(x_1)) = 0 POL(LOOP(x_1, x_2, x_3)) = x_3 POL(MAPITER(x_1, x_2)) = x_1 POL(c(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c20(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c8(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = x_2 POL(double(x_1)) = [1] + x_1 POL(droplast(x_1)) = x_1 POL(error) = [1] POL(false) = 0 POL(if(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4 POL(last(x_1)) = [1] POL(le(x_1, x_2)) = [1] + x_1 POL(log(x_1)) = [1] POL(logError) = [1] POL(loop(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3 POL(nil) = [1] POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (126) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) K tuples: IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2 ---------------------------------------- (127) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) by IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) ---------------------------------------- (128) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) K tuples: IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2 ---------------------------------------- (129) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) by IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) ---------------------------------------- (130) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) K tuples: IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2, c14_2 ---------------------------------------- (131) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) We considered the (Usable) Rules: droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil And the Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(DOUBLE(x_1)) = 0 POL(DROPLAST(x_1)) = 0 POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4 POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2 POL(LAST(x_1)) = 0 POL(LE(x_1, x_2)) = 0 POL(LOG(x_1)) = 0 POL(LOOP(x_1, x_2, x_3)) = x_3 POL(MAPITER(x_1, x_2)) = x_1 POL(c(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c20(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c8(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_2 POL(double(x_1)) = [1] + x_1 POL(droplast(x_1)) = x_1 POL(error) = [1] POL(false) = 0 POL(if(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4 POL(last(x_1)) = [1] POL(le(x_1, x_2)) = [1] + x_1 POL(log(x_1)) = [1] POL(logError) = [1] POL(loop(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (132) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) K tuples: IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2, c14_2 ---------------------------------------- (133) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) by IFMAP(false, nil, x0) -> c14(MAPITER(nil, cons(log(error), x0))) ---------------------------------------- (134) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, nil, x0) -> c14(MAPITER(nil, cons(log(error), x0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) K tuples: IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2, c14_2 ---------------------------------------- (135) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFMAP(false, nil, x0) -> c14(MAPITER(nil, cons(log(error), x0))) ---------------------------------------- (136) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2, c14_2 ---------------------------------------- (137) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) by IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(z0), x1))) ---------------------------------------- (138) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(z0), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(z0), x1))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2, c14_2, c14_1 ---------------------------------------- (139) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(z0), x1))) ---------------------------------------- (140) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2, c14_2, c14_1 ---------------------------------------- (141) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) by LOOP(s(s(0)), s(s(z0)), x2) -> c8(IF(true, s(s(0)), s(s(z0)), x2), LE(s(s(0)), s(s(z0)))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) ---------------------------------------- (142) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(IF(true, s(s(0)), s(s(z0)), x2), LE(s(s(0)), s(s(z0)))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(IF(true, s(s(0)), s(s(z0)), x2), LE(s(s(0)), s(s(z0)))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_3, c15_1, c15_2, c14_2, c14_1, c8_2 ---------------------------------------- (143) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (144) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_3, c15_1, c15_2, c14_2, c14_1, c8_2 ---------------------------------------- (145) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) by IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) ---------------------------------------- (146) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_3, c15_1, c15_2, c14_2, c14_1, c8_2 ---------------------------------------- (147) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) by IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) ---------------------------------------- (148) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3 ---------------------------------------- (149) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) We considered the (Usable) Rules: droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil And the Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(DOUBLE(x_1)) = 0 POL(DROPLAST(x_1)) = 0 POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4 POL(IFMAP(x_1, x_2, x_3)) = [1] + x_1 + x_2 POL(LAST(x_1)) = 0 POL(LE(x_1, x_2)) = 0 POL(LOG(x_1)) = 0 POL(LOOP(x_1, x_2, x_3)) = x_3 POL(MAPITER(x_1, x_2)) = [1] + x_1 POL(c(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c20(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c8(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_2 POL(double(x_1)) = [1] + x_1 POL(droplast(x_1)) = x_1 POL(error) = [1] POL(false) = 0 POL(if(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4 POL(last(x_1)) = [1] POL(le(x_1, x_2)) = [1] + x_1 POL(log(x_1)) = [1] POL(logError) = [1] POL(loop(x_1, x_2, x_3)) = [1] + x_1 + x_3 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (150) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3 ---------------------------------------- (151) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) by IFMAP(false, nil, x0) -> c15(MAPITER(nil, cons(log(error), x0))) ---------------------------------------- (152) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, nil, x0) -> c15(MAPITER(nil, cons(log(error), x0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) K tuples: IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3 ---------------------------------------- (153) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFMAP(false, nil, x0) -> c15(MAPITER(nil, cons(log(error), x0))) ---------------------------------------- (154) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) droplast(nil) -> nil log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3 ---------------------------------------- (155) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: droplast(nil) -> nil ---------------------------------------- (156) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3 ---------------------------------------- (157) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) by IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1))) ---------------------------------------- (158) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3 ---------------------------------------- (159) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1))) ---------------------------------------- (160) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3 ---------------------------------------- (161) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) by IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) ---------------------------------------- (162) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3 ---------------------------------------- (163) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) by IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) ---------------------------------------- (164) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_2, c15_1, c14_2, c14_1, c8_2, c15_3 ---------------------------------------- (165) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) We considered the (Usable) Rules: droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) And the Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(DOUBLE(x_1)) = 0 POL(DROPLAST(x_1)) = 0 POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4 POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2 POL(LAST(x_1)) = 0 POL(LE(x_1, x_2)) = 0 POL(LOG(x_1)) = 0 POL(LOOP(x_1, x_2, x_3)) = x_3 POL(MAPITER(x_1, x_2)) = x_1 POL(c(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c20(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c8(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_2 POL(double(x_1)) = [1] + x_1 POL(droplast(x_1)) = x_1 POL(false) = 0 POL(if(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4 POL(last(x_1)) = [1] + x_1 POL(le(x_1, x_2)) = [1] + x_1 POL(log(x_1)) = [1] POL(logError) = [1] POL(loop(x_1, x_2, x_3)) = [1] + x_1 + x_3 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (166) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_2, c15_1, c14_2, c14_1, c8_2, c15_3 ---------------------------------------- (167) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) by IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)), LOG(0)) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1)), LOG(z0)) ---------------------------------------- (168) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)), LOG(0)) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1)), LOG(z0)) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)), LOG(0)) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1)), LOG(z0)) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2 ---------------------------------------- (169) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (170) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2 ---------------------------------------- (171) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) ---------------------------------------- (172) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2 ---------------------------------------- (173) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) by IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) ---------------------------------------- (174) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2 ---------------------------------------- (175) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) by IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) ---------------------------------------- (176) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2 ---------------------------------------- (177) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) by IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) ---------------------------------------- (178) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2 ---------------------------------------- (179) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) by IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) ---------------------------------------- (180) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2 ---------------------------------------- (181) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) We considered the (Usable) Rules: droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) And the Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(DOUBLE(x_1)) = 0 POL(DROPLAST(x_1)) = 0 POL(IF(x_1, x_2, x_3, x_4)) = 0 POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2 POL(LAST(x_1)) = 0 POL(LE(x_1, x_2)) = 0 POL(LOG(x_1)) = 0 POL(LOOP(x_1, x_2, x_3)) = 0 POL(MAPITER(x_1, x_2)) = x_1 POL(c(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c20(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c8(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_1 + x_2 POL(double(x_1)) = [1] + x_1 POL(droplast(x_1)) = x_1 POL(false) = 0 POL(if(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4 POL(last(x_1)) = [1] + x_1 POL(le(x_1, x_2)) = [1] + x_1 POL(log(x_1)) = [1] POL(logError) = [1] POL(loop(x_1, x_2, x_3)) = [1] + x_1 + x_3 POL(nil) = 0 POL(s(x_1)) = [1] POL(true) = [1] ---------------------------------------- (182) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2 ---------------------------------------- (183) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) by IFMAP(false, cons(0, nil), x0) -> c14(MAPITER(nil, cons(logError, x0))) ---------------------------------------- (184) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(0, nil), x0) -> c14(MAPITER(nil, cons(logError, x0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(0, nil), x0) -> c14(MAPITER(nil, cons(logError, x0))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2 ---------------------------------------- (185) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFMAP(false, cons(0, nil), x0) -> c14(MAPITER(nil, cons(logError, x0))) ---------------------------------------- (186) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2 ---------------------------------------- (187) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) by IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1))) ---------------------------------------- (188) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1 ---------------------------------------- (189) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1))) ---------------------------------------- (190) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1 ---------------------------------------- (191) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) by LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(IF(true, s(s(s(0))), s(s(s(z0))), x2), LE(s(s(s(0))), s(s(s(z0))))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) ---------------------------------------- (192) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(IF(true, s(s(s(0))), s(s(s(z0))), x2), LE(s(s(s(0))), s(s(s(z0))))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(IF(true, s(s(s(0))), s(s(s(z0))), x2), LE(s(s(s(0))), s(s(s(z0))))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1 ---------------------------------------- (193) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (194) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1 ---------------------------------------- (195) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) by IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) ---------------------------------------- (196) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1 ---------------------------------------- (197) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) We considered the (Usable) Rules: droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) And the Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(DOUBLE(x_1)) = 0 POL(DROPLAST(x_1)) = 0 POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4 POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2 POL(LAST(x_1)) = 0 POL(LE(x_1, x_2)) = 0 POL(LOG(x_1)) = 0 POL(LOOP(x_1, x_2, x_3)) = x_3 POL(MAPITER(x_1, x_2)) = x_1 POL(c(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c20(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c8(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = x_2 POL(double(x_1)) = [1] + x_1 POL(droplast(x_1)) = x_1 POL(false) = 0 POL(if(x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4 POL(last(x_1)) = [1] + x_1 POL(le(x_1, x_2)) = 0 POL(log(x_1)) = [1] POL(logError) = [1] POL(loop(x_1, x_2, x_3)) = [1] + x_3 POL(nil) = [1] POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (198) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1 ---------------------------------------- (199) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) by IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) ---------------------------------------- (200) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1 ---------------------------------------- (201) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) We considered the (Usable) Rules:none And the Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(DOUBLE(x_1)) = 0 POL(DROPLAST(x_1)) = 0 POL(IF(x_1, x_2, x_3, x_4)) = 0 POL(IFMAP(x_1, x_2, x_3)) = [1] + [3]x_1 + x_2 POL(LAST(x_1)) = 0 POL(LE(x_1, x_2)) = 0 POL(LOG(x_1)) = 0 POL(LOOP(x_1, x_2, x_3)) = 0 POL(MAPITER(x_1, x_2)) = [2] POL(c(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c20(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c8(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] POL(double(x_1)) = [3]x_1 POL(droplast(x_1)) = 0 POL(false) = 0 POL(if(x_1, x_2, x_3, x_4)) = [3] + [3]x_2 + [3]x_3 + [3]x_4 POL(last(x_1)) = 0 POL(le(x_1, x_2)) = 0 POL(log(x_1)) = [3] POL(logError) = [3] POL(loop(x_1, x_2, x_3)) = 0 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [3] ---------------------------------------- (202) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1 ---------------------------------------- (203) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) by IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) ---------------------------------------- (204) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1 ---------------------------------------- (205) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) by IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) ---------------------------------------- (206) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1 ---------------------------------------- (207) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) by IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) ---------------------------------------- (208) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3 ---------------------------------------- (209) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) ---------------------------------------- (210) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3 ---------------------------------------- (211) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) We considered the (Usable) Rules: droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) And the Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(DOUBLE(x_1)) = 0 POL(DROPLAST(x_1)) = 0 POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4 POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2 POL(LAST(x_1)) = 0 POL(LE(x_1, x_2)) = 0 POL(LOG(x_1)) = 0 POL(LOOP(x_1, x_2, x_3)) = x_3 POL(MAPITER(x_1, x_2)) = x_1 POL(c(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c20(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c8(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_2 POL(double(x_1)) = [1] + x_1 POL(droplast(x_1)) = x_1 POL(false) = 0 POL(if(x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4 POL(last(x_1)) = [1] + x_1 POL(le(x_1, x_2)) = 0 POL(log(x_1)) = [1] POL(logError) = [1] POL(loop(x_1, x_2, x_3)) = [1] + x_3 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (212) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3 ---------------------------------------- (213) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) by IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0))) ---------------------------------------- (214) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3 ---------------------------------------- (215) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0))) ---------------------------------------- (216) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3 ---------------------------------------- (217) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) by IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1))) ---------------------------------------- (218) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3 ---------------------------------------- (219) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1))) ---------------------------------------- (220) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3 ---------------------------------------- (221) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) by IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) ---------------------------------------- (222) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3 ---------------------------------------- (223) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) by IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) ---------------------------------------- (224) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3 ---------------------------------------- (225) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) by IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) ---------------------------------------- (226) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3 ---------------------------------------- (227) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) by IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) ---------------------------------------- (228) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3 ---------------------------------------- (229) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) We considered the (Usable) Rules: droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) And the Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(DOUBLE(x_1)) = 0 POL(DROPLAST(x_1)) = 0 POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4 POL(IFMAP(x_1, x_2, x_3)) = [1] + x_1 + x_2 POL(LAST(x_1)) = 0 POL(LE(x_1, x_2)) = 0 POL(LOG(x_1)) = 0 POL(LOOP(x_1, x_2, x_3)) = x_3 POL(MAPITER(x_1, x_2)) = [1] + x_1 POL(c(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c20(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c8(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_2 POL(double(x_1)) = [1] + x_1 POL(droplast(x_1)) = x_1 POL(false) = 0 POL(if(x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4 POL(last(x_1)) = [1] + x_1 POL(le(x_1, x_2)) = 0 POL(log(x_1)) = [1] POL(logError) = [1] POL(loop(x_1, x_2, x_3)) = [1] + x_3 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (230) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3 ---------------------------------------- (231) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) by IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) ---------------------------------------- (232) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2 ---------------------------------------- (233) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (234) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2 ---------------------------------------- (235) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) We considered the (Usable) Rules: droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) And the Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(DOUBLE(x_1)) = 0 POL(DROPLAST(x_1)) = 0 POL(IF(x_1, x_2, x_3, x_4)) = 0 POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2 POL(LAST(x_1)) = 0 POL(LE(x_1, x_2)) = 0 POL(LOG(x_1)) = 0 POL(LOOP(x_1, x_2, x_3)) = 0 POL(MAPITER(x_1, x_2)) = x_1 POL(c(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c20(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c8(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = x_1 POL(double(x_1)) = [1] + x_1 POL(droplast(x_1)) = x_1 POL(false) = 0 POL(if(x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4 POL(last(x_1)) = [1] + x_1 POL(le(x_1, x_2)) = 0 POL(log(x_1)) = [1] POL(logError) = [1] POL(loop(x_1, x_2, x_3)) = [1] + x_3 POL(nil) = 0 POL(s(x_1)) = [1] POL(true) = [1] ---------------------------------------- (236) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2 ---------------------------------------- (237) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) by IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0))) ---------------------------------------- (238) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2 ---------------------------------------- (239) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0))) ---------------------------------------- (240) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2 ---------------------------------------- (241) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) by IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) ---------------------------------------- (242) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2 ---------------------------------------- (243) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) by IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil)))) IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil)))) ---------------------------------------- (244) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil)))) IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil)))) IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil)))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2 ---------------------------------------- (245) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) by IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(cons(x0, droplast(cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(cons(x0, droplast(cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil)))) ---------------------------------------- (246) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil)))) IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil)))) IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil)))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2 ---------------------------------------- (247) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil)))) We considered the (Usable) Rules: droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) And the Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil)))) IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(DOUBLE(x_1)) = 0 POL(DROPLAST(x_1)) = 0 POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4 POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2 POL(LAST(x_1)) = 0 POL(LE(x_1, x_2)) = 0 POL(LOG(x_1)) = 0 POL(LOOP(x_1, x_2, x_3)) = x_3 POL(MAPITER(x_1, x_2)) = x_1 POL(c(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c20(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c8(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_2 POL(double(x_1)) = [1] + x_1 POL(droplast(x_1)) = x_1 POL(false) = 0 POL(if(x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4 POL(last(x_1)) = [1] + x_1 POL(le(x_1, x_2)) = 0 POL(log(x_1)) = [1] POL(logError) = [1] POL(loop(x_1, x_2, x_3)) = [1] + x_3 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (248) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil)))) IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil)))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil)))) IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil)))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2 ---------------------------------------- (249) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) by IFMAP(false, cons(x0, cons(x1, cons(0, nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(0, nil)))), cons(logError, x3)), DROPLAST(cons(x0, cons(x1, cons(0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(s(z0), nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(s(z0), nil)))), cons(loop(s(z0), s(0), 0), x3)), DROPLAST(cons(x0, cons(x1, cons(s(z0), nil))))) IFMAP(false, cons(z0, cons(z1, cons(x2, nil))), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, nil)))), cons(log(x2), x3)), DROPLAST(cons(z0, cons(z1, cons(x2, nil))))) ---------------------------------------- (250) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil)))) IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(x1, cons(0, nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(0, nil)))), cons(logError, x3)), DROPLAST(cons(x0, cons(x1, cons(0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(s(z0), nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(s(z0), nil)))), cons(loop(s(z0), s(0), 0), x3)), DROPLAST(cons(x0, cons(x1, cons(s(z0), nil))))) IFMAP(false, cons(z0, cons(z1, cons(x2, nil))), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, nil)))), cons(log(x2), x3)), DROPLAST(cons(z0, cons(z1, cons(x2, nil))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil)))) IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil)))) IFMAP(false, cons(x0, cons(x1, cons(0, nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(0, nil)))), cons(logError, x3)), DROPLAST(cons(x0, cons(x1, cons(0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(s(z0), nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(s(z0), nil)))), cons(loop(s(z0), s(0), 0), x3)), DROPLAST(cons(x0, cons(x1, cons(s(z0), nil))))) IFMAP(false, cons(z0, cons(z1, cons(x2, nil))), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, nil)))), cons(log(x2), x3)), DROPLAST(cons(z0, cons(z1, cons(x2, nil))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2 ---------------------------------------- (251) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) by IFMAP(false, cons(x0, cons(x1, cons(x2, cons(z0, nil)))), x5) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(x2, cons(z0, nil))))), cons(log(z0), x5)), DROPLAST(cons(x0, cons(x1, cons(x2, cons(z0, nil)))))) IFMAP(false, cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2))))), x5) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2)))))), cons(log(last(cons(z1, z2))), x5)), DROPLAST(cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2))))))) IFMAP(false, cons(z0, cons(z1, cons(x2, cons(x3, x4)))), x5) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, cons(x3, x4))))), cons(log(last(cons(x3, x4))), x5)), DROPLAST(cons(z0, cons(z1, cons(x2, cons(x3, x4)))))) ---------------------------------------- (252) Obligation: Complexity Dependency Tuples Problem Rules: double(0) -> 0 double(s(z0)) -> s(s(double(z0))) droplast(cons(z0, nil)) -> nil droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2))) log(0) -> logError log(s(z0)) -> loop(s(z0), s(0), 0) loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2) if(true, z0, z1, z2) -> z2 if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2)) le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) le(s(z0), 0) -> false last(cons(z0, nil)) -> z0 last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2)) Tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil)))) IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil)))) IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(x1, cons(0, nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(0, nil)))), cons(logError, x3)), DROPLAST(cons(x0, cons(x1, cons(0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(s(z0), nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(s(z0), nil)))), cons(loop(s(z0), s(0), 0), x3)), DROPLAST(cons(x0, cons(x1, cons(s(z0), nil))))) IFMAP(false, cons(z0, cons(z1, cons(x2, nil))), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, nil)))), cons(log(x2), x3)), DROPLAST(cons(z0, cons(z1, cons(x2, nil))))) IFMAP(false, cons(x0, cons(x1, cons(x2, cons(z0, nil)))), x5) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(x2, cons(z0, nil))))), cons(log(z0), x5)), DROPLAST(cons(x0, cons(x1, cons(x2, cons(z0, nil)))))) IFMAP(false, cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2))))), x5) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2)))))), cons(log(last(cons(z1, z2))), x5)), DROPLAST(cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2))))))) IFMAP(false, cons(z0, cons(z1, cons(x2, cons(x3, x4)))), x5) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, cons(x3, x4))))), cons(log(last(cons(x3, x4))), x5)), DROPLAST(cons(z0, cons(z1, cons(x2, cons(x3, x4)))))) S tuples: LE(s(z0), s(z1)) -> c3(LE(z0, z1)) DOUBLE(s(z0)) -> c5(DOUBLE(z0)) LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0)) LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2))) DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2))) IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0))) MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1)) LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1))) LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0))) LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2)) LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2)))) LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0)))) LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1)))) LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0)))) IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1)))))) LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0))))) LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1))))) LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0))))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil)))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil)))) IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2))))) IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2)))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1))) IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2))) IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2))) IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4))) IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4))) IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0))) IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil)))) IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil)))) IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil)))) IFMAP(false, cons(x0, cons(x1, cons(0, nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(0, nil)))), cons(logError, x3)), DROPLAST(cons(x0, cons(x1, cons(0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(s(z0), nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(s(z0), nil)))), cons(loop(s(z0), s(0), 0), x3)), DROPLAST(cons(x0, cons(x1, cons(s(z0), nil))))) IFMAP(false, cons(z0, cons(z1, cons(x2, nil))), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, nil)))), cons(log(x2), x3)), DROPLAST(cons(z0, cons(z1, cons(x2, nil))))) IFMAP(false, cons(x0, cons(x1, cons(x2, cons(z0, nil)))), x5) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(x2, cons(z0, nil))))), cons(log(z0), x5)), DROPLAST(cons(x0, cons(x1, cons(x2, cons(z0, nil)))))) IFMAP(false, cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2))))), x5) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2)))))), cons(log(last(cons(z1, z2))), x5)), DROPLAST(cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2))))))) IFMAP(false, cons(z0, cons(z1, cons(x2, cons(x3, x4)))), x5) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, cons(x3, x4))))), cons(log(last(cons(x3, x4))), x5)), DROPLAST(cons(z0, cons(z1, cons(x2, cons(x3, x4)))))) K tuples: IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0)) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil)))) IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil))))) IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4))) IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0))) IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil)))) Defined Rule Symbols: double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1 Defined Pair Symbols: LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3 Compound Symbols: c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2