KILLED proof of input_1T9Vb7fkVR.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), 0 ms] (14) CpxRNTS (15) InliningProof [UPPER BOUND(ID), 267 ms] (16) CpxRNTS (17) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms] (18) CpxRNTS (19) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms] (20) CpxRNTS (21) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (22) CpxRNTS (23) IntTrsBoundProof [UPPER BOUND(ID), 113 ms] (24) CpxRNTS (25) IntTrsBoundProof [UPPER BOUND(ID), 6 ms] (26) CpxRNTS (27) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (28) CpxRNTS (29) IntTrsBoundProof [UPPER BOUND(ID), 103 ms] (30) CpxRNTS (31) IntTrsBoundProof [UPPER BOUND(ID), 43 ms] (32) CpxRNTS (33) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (34) CpxRNTS (35) IntTrsBoundProof [UPPER BOUND(ID), 358 ms] (36) CpxRNTS (37) IntTrsBoundProof [UPPER BOUND(ID), 159 ms] (38) CpxRNTS (39) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (40) CpxRNTS (41) IntTrsBoundProof [UPPER BOUND(ID), 172 ms] (42) CpxRNTS (43) IntTrsBoundProof [UPPER BOUND(ID), 55 ms] (44) CpxRNTS (45) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (46) CpxRNTS (47) IntTrsBoundProof [UPPER BOUND(ID), 6061 ms] (48) CpxRNTS (49) IntTrsBoundProof [UPPER BOUND(ID), 2163 ms] (50) CpxRNTS (51) CompletionProof [UPPER BOUND(ID), 0 ms] (52) CpxTypedWeightedCompleteTrs (53) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms] (54) CpxRNTS (55) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms] (56) CdtProblem (57) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (58) CdtProblem (59) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (60) CdtProblem (61) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (62) CdtProblem (63) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (64) CdtProblem (65) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (66) CdtProblem (67) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 37 ms] (68) CdtProblem (69) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (70) CdtProblem (71) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (72) CdtProblem (73) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 20 ms] (74) CdtProblem (75) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (76) CdtProblem (77) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (78) CdtProblem (79) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 25 ms] (80) CdtProblem (81) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (82) CdtProblem (83) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (84) CdtProblem (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (86) CdtProblem (87) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 32 ms] (88) CdtProblem (89) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (90) CdtProblem (91) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (92) CdtProblem (93) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (94) CdtProblem (95) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (96) CdtProblem (97) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 28 ms] (98) CdtProblem (99) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 1 ms] (100) CdtProblem (101) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (102) CdtProblem (103) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 25 ms] (104) CdtProblem (105) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (106) CdtProblem (107) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 39 ms] (108) CdtProblem (109) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (110) CdtProblem (111) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 37 ms] (112) CdtProblem (113) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (114) CdtProblem (115) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (116) CdtProblem (117) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (118) CdtProblem (119) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (120) CdtProblem (121) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (122) CdtProblem (123) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (124) CdtProblem (125) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (126) CdtProblem (127) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (128) CdtProblem (129) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (130) CdtProblem (131) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (132) CdtProblem (133) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (134) CdtProblem (135) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (136) CdtProblem (137) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (138) CdtProblem (139) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (140) CdtProblem (141) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (142) CdtProblem (143) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (144) CdtProblem (145) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (146) CdtProblem (147) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (148) CdtProblem (149) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (150) CdtProblem (151) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (152) CdtProblem (153) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (154) CdtProblem (155) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (156) CdtProblem (157) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (158) CdtProblem (159) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (160) CdtProblem (161) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (162) CdtProblem (163) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (164) CdtProblem (165) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (166) CdtProblem (167) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (168) CdtProblem (169) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (170) CdtProblem (171) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (172) CdtProblem (173) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (174) CdtProblem (175) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (176) CdtProblem (177) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (178) CdtProblem (179) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (180) CdtProblem (181) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (182) CdtProblem (183) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (184) CdtProblem (185) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (186) CdtProblem (187) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (188) CdtProblem (189) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (190) CdtProblem (191) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (192) CdtProblem (193) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (194) CdtProblem (195) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (196) CdtProblem ---------------------------------------- (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: sum(cons(s(n), x), cons(m, y)) -> sum(cons(n, x), cons(s(m), y)) sum(cons(0, x), y) -> sum(x, y) sum(nil, y) -> y empty(nil) -> true empty(cons(n, x)) -> false tail(nil) -> nil tail(cons(n, x)) -> x head(cons(n, x)) -> n weight(x) -> if(empty(x), empty(tail(x)), x) if(true, b, x) -> weight_undefined_error if(false, b, x) -> if2(b, x) if2(true, x) -> head(x) if2(false, x) -> weight(sum(x, cons(0, tail(tail(x))))) 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: sum(cons(s(n), x), cons(m, y)) -> sum(cons(n, x), cons(s(m), y)) sum(cons(0', x), y) -> sum(x, y) sum(nil, y) -> y empty(nil) -> true empty(cons(n, x)) -> false tail(nil) -> nil tail(cons(n, x)) -> x head(cons(n, x)) -> n weight(x) -> if(empty(x), empty(tail(x)), x) if(true, b, x) -> weight_undefined_error if(false, b, x) -> if2(b, x) if2(true, x) -> head(x) if2(false, x) -> weight(sum(x, cons(0', tail(tail(x))))) 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: sum(cons(s(n), x), cons(m, y)) -> sum(cons(n, x), cons(s(m), y)) sum(cons(0, x), y) -> sum(x, y) sum(nil, y) -> y empty(nil) -> true empty(cons(n, x)) -> false tail(nil) -> nil tail(cons(n, x)) -> x head(cons(n, x)) -> n weight(x) -> if(empty(x), empty(tail(x)), x) if(true, b, x) -> weight_undefined_error if(false, b, x) -> if2(b, x) if2(true, x) -> head(x) if2(false, x) -> weight(sum(x, cons(0, tail(tail(x))))) 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: sum(cons(s(n), x), cons(m, y)) -> sum(cons(n, x), cons(s(m), y)) [1] sum(cons(0, x), y) -> sum(x, y) [1] sum(nil, y) -> y [1] empty(nil) -> true [1] empty(cons(n, x)) -> false [1] tail(nil) -> nil [1] tail(cons(n, x)) -> x [1] head(cons(n, x)) -> n [1] weight(x) -> if(empty(x), empty(tail(x)), x) [1] if(true, b, x) -> weight_undefined_error [1] if(false, b, x) -> if2(b, x) [1] if2(true, x) -> head(x) [1] if2(false, x) -> weight(sum(x, cons(0, tail(tail(x))))) [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: sum(cons(s(n), x), cons(m, y)) -> sum(cons(n, x), cons(s(m), y)) [1] sum(cons(0, x), y) -> sum(x, y) [1] sum(nil, y) -> y [1] empty(nil) -> true [1] empty(cons(n, x)) -> false [1] tail(nil) -> nil [1] tail(cons(n, x)) -> x [1] head(cons(n, x)) -> n [1] weight(x) -> if(empty(x), empty(tail(x)), x) [1] if(true, b, x) -> weight_undefined_error [1] if(false, b, x) -> if2(b, x) [1] if2(true, x) -> head(x) [1] if2(false, x) -> weight(sum(x, cons(0, tail(tail(x))))) [1] The TRS has the following type information: sum :: cons:nil -> cons:nil -> cons:nil cons :: s:0:weight_undefined_error -> cons:nil -> cons:nil s :: s:0:weight_undefined_error -> s:0:weight_undefined_error 0 :: s:0:weight_undefined_error nil :: cons:nil empty :: cons:nil -> true:false true :: true:false false :: true:false tail :: cons:nil -> cons:nil head :: cons:nil -> s:0:weight_undefined_error weight :: cons:nil -> s:0:weight_undefined_error if :: true:false -> true:false -> cons:nil -> s:0:weight_undefined_error weight_undefined_error :: s:0:weight_undefined_error if2 :: true:false -> cons:nil -> s:0:weight_undefined_error 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: head_1 weight_1 if_3 if2_2 (c) The following functions are completely defined: empty_1 tail_1 sum_2 Due to the following rules being added: sum(v0, v1) -> nil [0] And the following fresh constants: none ---------------------------------------- (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: sum(cons(s(n), x), cons(m, y)) -> sum(cons(n, x), cons(s(m), y)) [1] sum(cons(0, x), y) -> sum(x, y) [1] sum(nil, y) -> y [1] empty(nil) -> true [1] empty(cons(n, x)) -> false [1] tail(nil) -> nil [1] tail(cons(n, x)) -> x [1] head(cons(n, x)) -> n [1] weight(x) -> if(empty(x), empty(tail(x)), x) [1] if(true, b, x) -> weight_undefined_error [1] if(false, b, x) -> if2(b, x) [1] if2(true, x) -> head(x) [1] if2(false, x) -> weight(sum(x, cons(0, tail(tail(x))))) [1] sum(v0, v1) -> nil [0] The TRS has the following type information: sum :: cons:nil -> cons:nil -> cons:nil cons :: s:0:weight_undefined_error -> cons:nil -> cons:nil s :: s:0:weight_undefined_error -> s:0:weight_undefined_error 0 :: s:0:weight_undefined_error nil :: cons:nil empty :: cons:nil -> true:false true :: true:false false :: true:false tail :: cons:nil -> cons:nil head :: cons:nil -> s:0:weight_undefined_error weight :: cons:nil -> s:0:weight_undefined_error if :: true:false -> true:false -> cons:nil -> s:0:weight_undefined_error weight_undefined_error :: s:0:weight_undefined_error if2 :: true:false -> cons:nil -> s:0:weight_undefined_error 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: sum(cons(s(n), x), cons(m, y)) -> sum(cons(n, x), cons(s(m), y)) [1] sum(cons(0, x), y) -> sum(x, y) [1] sum(nil, y) -> y [1] empty(nil) -> true [1] empty(cons(n, x)) -> false [1] tail(nil) -> nil [1] tail(cons(n, x)) -> x [1] head(cons(n, x)) -> n [1] weight(nil) -> if(true, empty(nil), nil) [3] weight(cons(n', x')) -> if(false, empty(x'), cons(n', x')) [3] if(true, b, x) -> weight_undefined_error [1] if(false, b, x) -> if2(b, x) [1] if2(true, x) -> head(x) [1] if2(false, nil) -> weight(sum(nil, cons(0, tail(nil)))) [2] if2(false, cons(n'', x'')) -> weight(sum(cons(n'', x''), cons(0, tail(x'')))) [2] sum(v0, v1) -> nil [0] The TRS has the following type information: sum :: cons:nil -> cons:nil -> cons:nil cons :: s:0:weight_undefined_error -> cons:nil -> cons:nil s :: s:0:weight_undefined_error -> s:0:weight_undefined_error 0 :: s:0:weight_undefined_error nil :: cons:nil empty :: cons:nil -> true:false true :: true:false false :: true:false tail :: cons:nil -> cons:nil head :: cons:nil -> s:0:weight_undefined_error weight :: cons:nil -> s:0:weight_undefined_error if :: true:false -> true:false -> cons:nil -> s:0:weight_undefined_error weight_undefined_error :: s:0:weight_undefined_error if2 :: true:false -> cons:nil -> s:0:weight_undefined_error 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 nil => 0 true => 1 false => 0 weight_undefined_error => 1 ---------------------------------------- (14) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(b, x) :|: b >= 0, x >= 0, z' = b, z'' = x, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: b >= 0, z = 1, x >= 0, z' = b, z'' = x if2(z, z') -{ 2 }-> weight(sum(0, 1 + 0 + tail(0))) :|: z = 0, z' = 0 if2(z, z') -{ 2 }-> weight(sum(1 + n'' + x'', 1 + 0 + tail(x''))) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0 if2(z, z') -{ 1 }-> head(x) :|: z' = x, z = 1, x >= 0 sum(z, z') -{ 1 }-> y :|: y >= 0, z = 0, z' = y sum(z, z') -{ 1 }-> sum(x, y) :|: x >= 0, y >= 0, z = 1 + 0 + x, z' = y sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 3 }-> if(1, empty(0), 0) :|: z = 0 weight(z) -{ 3 }-> if(0, empty(x'), 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0 ---------------------------------------- (15) InliningProof (UPPER BOUND(ID)) Inlined the following terminating rules on right-hand sides where appropriate: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x ---------------------------------------- (16) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(b, x) :|: b >= 0, x >= 0, z' = b, z'' = x, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: b >= 0, z = 1, x >= 0, z' = b, z'' = x if2(z, z') -{ 2 }-> n :|: z' = x, z = 1, x >= 0, n >= 0, x' >= 0, x = 1 + n + x' if2(z, z') -{ 3 }-> weight(sum(0, 1 + 0 + 0)) :|: z = 0, z' = 0, 0 = 0 if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + x)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + 0)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 1 }-> y :|: y >= 0, z = 0, z' = y sum(z, z') -{ 1 }-> sum(x, y) :|: x >= 0, y >= 0, z = 1 + 0 + x, z' = y sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x ---------------------------------------- (17) SimplificationProof (BOTH BOUNDS(ID, ID)) Simplified the RNTS by moving equalities from the constraints into the right-hand sides. ---------------------------------------- (18) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 3 }-> weight(sum(0, 1 + 0 + 0)) :|: z = 0, z' = 0, 0 = 0 if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + x)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + 0)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 1 }-> sum(z - 1, z') :|: z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x ---------------------------------------- (19) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID)) Found the following analysis order by SCC decomposition: { empty } { head } { sum } { tail } { if2, weight, if } ---------------------------------------- (20) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 3 }-> weight(sum(0, 1 + 0 + 0)) :|: z = 0, z' = 0, 0 = 0 if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + x)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + 0)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 1 }-> sum(z - 1, z') :|: z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {empty}, {head}, {sum}, {tail}, {if2,weight,if} ---------------------------------------- (21) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (22) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 3 }-> weight(sum(0, 1 + 0 + 0)) :|: z = 0, z' = 0, 0 = 0 if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + x)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + 0)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 1 }-> sum(z - 1, z') :|: z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {empty}, {head}, {sum}, {tail}, {if2,weight,if} ---------------------------------------- (23) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: empty after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (24) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 3 }-> weight(sum(0, 1 + 0 + 0)) :|: z = 0, z' = 0, 0 = 0 if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + x)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + 0)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 1 }-> sum(z - 1, z') :|: z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {empty}, {head}, {sum}, {tail}, {if2,weight,if} Previous analysis results are: empty: runtime: ?, size: O(1) [1] ---------------------------------------- (25) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: empty after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (26) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 3 }-> weight(sum(0, 1 + 0 + 0)) :|: z = 0, z' = 0, 0 = 0 if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + x)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + 0)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 1 }-> sum(z - 1, z') :|: z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {head}, {sum}, {tail}, {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] ---------------------------------------- (27) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (28) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 3 }-> weight(sum(0, 1 + 0 + 0)) :|: z = 0, z' = 0, 0 = 0 if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + x)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + 0)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 1 }-> sum(z - 1, z') :|: z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {head}, {sum}, {tail}, {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] ---------------------------------------- (29) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: head after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z ---------------------------------------- (30) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 3 }-> weight(sum(0, 1 + 0 + 0)) :|: z = 0, z' = 0, 0 = 0 if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + x)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + 0)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 1 }-> sum(z - 1, z') :|: z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {head}, {sum}, {tail}, {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] head: runtime: ?, size: O(n^1) [z] ---------------------------------------- (31) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: head after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (32) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 3 }-> weight(sum(0, 1 + 0 + 0)) :|: z = 0, z' = 0, 0 = 0 if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + x)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + 0)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 1 }-> sum(z - 1, z') :|: z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {sum}, {tail}, {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] head: runtime: O(1) [1], size: O(n^1) [z] ---------------------------------------- (33) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (34) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 3 }-> weight(sum(0, 1 + 0 + 0)) :|: z = 0, z' = 0, 0 = 0 if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + x)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + 0)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 1 }-> sum(z - 1, z') :|: z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {sum}, {tail}, {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] head: runtime: O(1) [1], size: O(n^1) [z] ---------------------------------------- (35) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: sum after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z + z' ---------------------------------------- (36) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 3 }-> weight(sum(0, 1 + 0 + 0)) :|: z = 0, z' = 0, 0 = 0 if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + x)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + 0)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 1 }-> sum(z - 1, z') :|: z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {sum}, {tail}, {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] head: runtime: O(1) [1], size: O(n^1) [z] sum: runtime: ?, size: O(n^1) [z + z'] ---------------------------------------- (37) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: sum after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z ---------------------------------------- (38) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 3 }-> weight(sum(0, 1 + 0 + 0)) :|: z = 0, z' = 0, 0 = 0 if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + x)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 3 }-> weight(sum(1 + n'' + x'', 1 + 0 + 0)) :|: z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 1 }-> sum(z - 1, z') :|: z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {tail}, {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] head: runtime: O(1) [1], size: O(n^1) [z] sum: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] ---------------------------------------- (39) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (40) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 4 }-> weight(s'') :|: s'' >= 0, s'' <= 0 + (1 + 0 + 0), z = 0, z' = 0, 0 = 0 if2(z, z') -{ 5 + n'' + x'' }-> weight(s1) :|: s1 >= 0, s1 <= 1 + n'' + x'' + (1 + 0 + x), z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 5 + n'' + x'' }-> weight(s2) :|: s2 >= 0, s2 <= 1 + n'' + x'' + (1 + 0 + 0), z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 3 + n + x }-> s :|: s >= 0, s <= 1 + n + x + (1 + (1 + m) + y), n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 1 + z }-> s' :|: s' >= 0, s' <= z - 1 + z', z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {tail}, {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] head: runtime: O(1) [1], size: O(n^1) [z] sum: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] ---------------------------------------- (41) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: tail after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z ---------------------------------------- (42) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 4 }-> weight(s'') :|: s'' >= 0, s'' <= 0 + (1 + 0 + 0), z = 0, z' = 0, 0 = 0 if2(z, z') -{ 5 + n'' + x'' }-> weight(s1) :|: s1 >= 0, s1 <= 1 + n'' + x'' + (1 + 0 + x), z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 5 + n'' + x'' }-> weight(s2) :|: s2 >= 0, s2 <= 1 + n'' + x'' + (1 + 0 + 0), z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 3 + n + x }-> s :|: s >= 0, s <= 1 + n + x + (1 + (1 + m) + y), n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 1 + z }-> s' :|: s' >= 0, s' <= z - 1 + z', z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {tail}, {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] head: runtime: O(1) [1], size: O(n^1) [z] sum: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] tail: runtime: ?, size: O(n^1) [z] ---------------------------------------- (43) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: tail after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (44) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 4 }-> weight(s'') :|: s'' >= 0, s'' <= 0 + (1 + 0 + 0), z = 0, z' = 0, 0 = 0 if2(z, z') -{ 5 + n'' + x'' }-> weight(s1) :|: s1 >= 0, s1 <= 1 + n'' + x'' + (1 + 0 + x), z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 5 + n'' + x'' }-> weight(s2) :|: s2 >= 0, s2 <= 1 + n'' + x'' + (1 + 0 + 0), z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 3 + n + x }-> s :|: s >= 0, s <= 1 + n + x + (1 + (1 + m) + y), n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 1 + z }-> s' :|: s' >= 0, s' <= z - 1 + z', z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] head: runtime: O(1) [1], size: O(n^1) [z] sum: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] tail: runtime: O(1) [1], size: O(n^1) [z] ---------------------------------------- (45) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (46) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 4 }-> weight(s'') :|: s'' >= 0, s'' <= 0 + (1 + 0 + 0), z = 0, z' = 0, 0 = 0 if2(z, z') -{ 5 + n'' + x'' }-> weight(s1) :|: s1 >= 0, s1 <= 1 + n'' + x'' + (1 + 0 + x), z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 5 + n'' + x'' }-> weight(s2) :|: s2 >= 0, s2 <= 1 + n'' + x'' + (1 + 0 + 0), z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 3 + n + x }-> s :|: s >= 0, s <= 1 + n + x + (1 + (1 + m) + y), n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 1 + z }-> s' :|: s' >= 0, s' <= z - 1 + z', z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] head: runtime: O(1) [1], size: O(n^1) [z] sum: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] tail: runtime: O(1) [1], size: O(n^1) [z] ---------------------------------------- (47) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: if2 after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? Computed SIZE bound using CoFloCo for: weight after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? Computed SIZE bound using CoFloCo for: if after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (48) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 4 }-> weight(s'') :|: s'' >= 0, s'' <= 0 + (1 + 0 + 0), z = 0, z' = 0, 0 = 0 if2(z, z') -{ 5 + n'' + x'' }-> weight(s1) :|: s1 >= 0, s1 <= 1 + n'' + x'' + (1 + 0 + x), z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 5 + n'' + x'' }-> weight(s2) :|: s2 >= 0, s2 <= 1 + n'' + x'' + (1 + 0 + 0), z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 3 + n + x }-> s :|: s >= 0, s <= 1 + n + x + (1 + (1 + m) + y), n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 1 + z }-> s' :|: s' >= 0, s' <= z - 1 + z', z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] head: runtime: O(1) [1], size: O(n^1) [z] sum: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] tail: runtime: O(1) [1], size: O(n^1) [z] if2: runtime: ?, size: INF weight: runtime: ?, size: INF if: runtime: ?, size: INF ---------------------------------------- (49) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: if2 after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (50) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 1 :|: z = 0 empty(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x if(z, z', z'') -{ 1 }-> if2(z', z'') :|: z' >= 0, z'' >= 0, z = 0 if(z, z', z'') -{ 1 }-> 1 :|: z' >= 0, z = 1, z'' >= 0 if2(z, z') -{ 2 }-> n :|: z = 1, z' >= 0, n >= 0, x' >= 0, z' = 1 + n + x' if2(z, z') -{ 4 }-> weight(s'') :|: s'' >= 0, s'' <= 0 + (1 + 0 + 0), z = 0, z' = 0, 0 = 0 if2(z, z') -{ 5 + n'' + x'' }-> weight(s1) :|: s1 >= 0, s1 <= 1 + n'' + x'' + (1 + 0 + x), z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, n >= 0, x >= 0, x'' = 1 + n + x if2(z, z') -{ 5 + n'' + x'' }-> weight(s2) :|: s2 >= 0, s2 <= 1 + n'' + x'' + (1 + 0 + 0), z' = 1 + n'' + x'', n'' >= 0, x'' >= 0, z = 0, x'' = 0 sum(z, z') -{ 3 + n + x }-> s :|: s >= 0, s <= 1 + n + x + (1 + (1 + m) + y), n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 1 + z }-> s' :|: s' >= 0, s' <= z - 1 + z', z - 1 >= 0, z' >= 0 sum(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 sum(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 weight(z) -{ 4 }-> if(1, 1, 0) :|: z = 0, 0 = 0 weight(z) -{ 4 }-> if(0, 1, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, x' = 0 weight(z) -{ 4 }-> if(0, 0, 1 + n' + x') :|: z = 1 + n' + x', x' >= 0, n' >= 0, n >= 0, x >= 0, x' = 1 + n + x Function symbols to be analyzed: {if2,weight,if} Previous analysis results are: empty: runtime: O(1) [1], size: O(1) [1] head: runtime: O(1) [1], size: O(n^1) [z] sum: runtime: O(n^1) [1 + z], size: O(n^1) [z + z'] tail: runtime: O(1) [1], size: O(n^1) [z] if2: runtime: INF, size: INF weight: runtime: ?, size: INF if: runtime: ?, size: INF ---------------------------------------- (51) 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: sum(v0, v1) -> null_sum [0] head(v0) -> null_head [0] empty(v0) -> null_empty [0] tail(v0) -> null_tail [0] if(v0, v1, v2) -> null_if [0] if2(v0, v1) -> null_if2 [0] And the following fresh constants: null_sum, null_head, null_empty, null_tail, null_if, null_if2 ---------------------------------------- (52) 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: sum(cons(s(n), x), cons(m, y)) -> sum(cons(n, x), cons(s(m), y)) [1] sum(cons(0, x), y) -> sum(x, y) [1] sum(nil, y) -> y [1] empty(nil) -> true [1] empty(cons(n, x)) -> false [1] tail(nil) -> nil [1] tail(cons(n, x)) -> x [1] head(cons(n, x)) -> n [1] weight(x) -> if(empty(x), empty(tail(x)), x) [1] if(true, b, x) -> weight_undefined_error [1] if(false, b, x) -> if2(b, x) [1] if2(true, x) -> head(x) [1] if2(false, x) -> weight(sum(x, cons(0, tail(tail(x))))) [1] sum(v0, v1) -> null_sum [0] head(v0) -> null_head [0] empty(v0) -> null_empty [0] tail(v0) -> null_tail [0] if(v0, v1, v2) -> null_if [0] if2(v0, v1) -> null_if2 [0] The TRS has the following type information: sum :: cons:nil:null_sum:null_tail -> cons:nil:null_sum:null_tail -> cons:nil:null_sum:null_tail cons :: s:0:weight_undefined_error:null_head:null_if:null_if2 -> cons:nil:null_sum:null_tail -> cons:nil:null_sum:null_tail s :: s:0:weight_undefined_error:null_head:null_if:null_if2 -> s:0:weight_undefined_error:null_head:null_if:null_if2 0 :: s:0:weight_undefined_error:null_head:null_if:null_if2 nil :: cons:nil:null_sum:null_tail empty :: cons:nil:null_sum:null_tail -> true:false:null_empty true :: true:false:null_empty false :: true:false:null_empty tail :: cons:nil:null_sum:null_tail -> cons:nil:null_sum:null_tail head :: cons:nil:null_sum:null_tail -> s:0:weight_undefined_error:null_head:null_if:null_if2 weight :: cons:nil:null_sum:null_tail -> s:0:weight_undefined_error:null_head:null_if:null_if2 if :: true:false:null_empty -> true:false:null_empty -> cons:nil:null_sum:null_tail -> s:0:weight_undefined_error:null_head:null_if:null_if2 weight_undefined_error :: s:0:weight_undefined_error:null_head:null_if:null_if2 if2 :: true:false:null_empty -> cons:nil:null_sum:null_tail -> s:0:weight_undefined_error:null_head:null_if:null_if2 null_sum :: cons:nil:null_sum:null_tail null_head :: s:0:weight_undefined_error:null_head:null_if:null_if2 null_empty :: true:false:null_empty null_tail :: cons:nil:null_sum:null_tail null_if :: s:0:weight_undefined_error:null_head:null_if:null_if2 null_if2 :: s:0:weight_undefined_error:null_head:null_if:null_if2 Rewrite Strategy: INNERMOST ---------------------------------------- (53) 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 nil => 0 true => 2 false => 1 weight_undefined_error => 1 null_sum => 0 null_head => 0 null_empty => 0 null_tail => 0 null_if => 0 null_if2 => 0 ---------------------------------------- (54) Obligation: Complexity RNTS consisting of the following rules: empty(z) -{ 1 }-> 2 :|: z = 0 empty(z) -{ 1 }-> 1 :|: n >= 0, x >= 0, z = 1 + n + x empty(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x head(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 if(z, z', z'') -{ 1 }-> if2(b, x) :|: b >= 0, z = 1, x >= 0, z' = b, z'' = x if(z, z', z'') -{ 1 }-> 1 :|: z = 2, b >= 0, x >= 0, z' = b, z'' = x if(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 if2(z, z') -{ 1 }-> weight(sum(x, 1 + 0 + tail(tail(x)))) :|: z' = x, z = 1, x >= 0 if2(z, z') -{ 1 }-> head(x) :|: z = 2, z' = x, x >= 0 if2(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 sum(z, z') -{ 1 }-> y :|: y >= 0, z = 0, z' = y sum(z, z') -{ 1 }-> sum(x, y) :|: x >= 0, y >= 0, z = 1 + 0 + x, z' = y sum(z, z') -{ 1 }-> sum(1 + n + x, 1 + (1 + m) + y) :|: n >= 0, z' = 1 + m + y, x >= 0, y >= 0, z = 1 + (1 + n) + x, m >= 0 sum(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x tail(z) -{ 1 }-> 0 :|: z = 0 tail(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 weight(z) -{ 1 }-> if(empty(x), empty(tail(x)), x) :|: x >= 0, z = x Only complete derivations are relevant for the runtime complexity. ---------------------------------------- (55) CpxTrsToCdtProof (UPPER BOUND(ID)) Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT ---------------------------------------- (56) Obligation: Complexity Dependency Tuples Problem Rules: sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 head(cons(z0, z1)) -> z0 weight(z0) -> if(empty(z0), empty(tail(z0)), z0) if(true, z0, z1) -> weight_undefined_error if(false, z0, z1) -> if2(z0, z1) if2(true, z0) -> head(z0) if2(false, z0) -> weight(sum(z0, cons(0, tail(tail(z0))))) Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) SUM(nil, z0) -> c2 EMPTY(nil) -> c3 EMPTY(cons(z0, z1)) -> c4 TAIL(nil) -> c5 TAIL(cons(z0, z1)) -> c6 HEAD(cons(z0, z1)) -> c7 WEIGHT(z0) -> c8(IF(empty(z0), empty(tail(z0)), z0), EMPTY(z0)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0), EMPTY(tail(z0)), TAIL(z0)) IF(true, z0, z1) -> c10 IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(true, z0) -> c12(HEAD(z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0)))), TAIL(tail(z0)), TAIL(z0)) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) SUM(nil, z0) -> c2 EMPTY(nil) -> c3 EMPTY(cons(z0, z1)) -> c4 TAIL(nil) -> c5 TAIL(cons(z0, z1)) -> c6 HEAD(cons(z0, z1)) -> c7 WEIGHT(z0) -> c8(IF(empty(z0), empty(tail(z0)), z0), EMPTY(z0)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0), EMPTY(tail(z0)), TAIL(z0)) IF(true, z0, z1) -> c10 IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(true, z0) -> c12(HEAD(z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0)))), TAIL(tail(z0)), TAIL(z0)) K tuples:none Defined Rule Symbols: sum_2, empty_1, tail_1, head_1, weight_1, if_3, if2_2 Defined Pair Symbols: SUM_2, EMPTY_1, TAIL_1, HEAD_1, WEIGHT_1, IF_3, IF2_2 Compound Symbols: c_1, c1_1, c2, c3, c4, c5, c6, c7, c8_2, c9_3, c10, c11_1, c12_1, c13_4 ---------------------------------------- (57) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 8 trailing nodes: IF2(true, z0) -> c12(HEAD(z0)) TAIL(cons(z0, z1)) -> c6 HEAD(cons(z0, z1)) -> c7 SUM(nil, z0) -> c2 EMPTY(nil) -> c3 EMPTY(cons(z0, z1)) -> c4 IF(true, z0, z1) -> c10 TAIL(nil) -> c5 ---------------------------------------- (58) Obligation: Complexity Dependency Tuples Problem Rules: sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 head(cons(z0, z1)) -> z0 weight(z0) -> if(empty(z0), empty(tail(z0)), z0) if(true, z0, z1) -> weight_undefined_error if(false, z0, z1) -> if2(z0, z1) if2(true, z0) -> head(z0) if2(false, z0) -> weight(sum(z0, cons(0, tail(tail(z0))))) Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(z0) -> c8(IF(empty(z0), empty(tail(z0)), z0), EMPTY(z0)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0), EMPTY(tail(z0)), TAIL(z0)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0)))), TAIL(tail(z0)), TAIL(z0)) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(z0) -> c8(IF(empty(z0), empty(tail(z0)), z0), EMPTY(z0)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0), EMPTY(tail(z0)), TAIL(z0)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0)))), TAIL(tail(z0)), TAIL(z0)) K tuples:none Defined Rule Symbols: sum_2, empty_1, tail_1, head_1, weight_1, if_3, if2_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF_3, IF2_2 Compound Symbols: c_1, c1_1, c8_2, c9_3, c11_1, c13_4 ---------------------------------------- (59) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 5 trailing tuple parts ---------------------------------------- (60) Obligation: Complexity Dependency Tuples Problem Rules: sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 head(cons(z0, z1)) -> z0 weight(z0) -> if(empty(z0), empty(tail(z0)), z0) if(true, z0, z1) -> weight_undefined_error if(false, z0, z1) -> if2(z0, z1) if2(true, z0) -> head(z0) if2(false, z0) -> weight(sum(z0, cons(0, tail(tail(z0))))) Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(z0) -> c8(IF(empty(z0), empty(tail(z0)), z0)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(z0) -> c8(IF(empty(z0), empty(tail(z0)), z0)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) K tuples:none Defined Rule Symbols: sum_2, empty_1, tail_1, head_1, weight_1, if_3, if2_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2 ---------------------------------------- (61) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: head(cons(z0, z1)) -> z0 weight(z0) -> if(empty(z0), empty(tail(z0)), z0) if(true, z0, z1) -> weight_undefined_error if(false, z0, z1) -> if2(z0, z1) if2(true, z0) -> head(z0) if2(false, z0) -> weight(sum(z0, cons(0, tail(tail(z0))))) ---------------------------------------- (62) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(z0) -> c8(IF(empty(z0), empty(tail(z0)), z0)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(z0) -> c8(IF(empty(z0), empty(tail(z0)), z0)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2 ---------------------------------------- (63) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace WEIGHT(z0) -> c8(IF(empty(z0), empty(tail(z0)), z0)) by WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(nil) -> c8(IF(true, empty(tail(nil)), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) ---------------------------------------- (64) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(nil) -> c8(IF(true, empty(tail(nil)), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(nil) -> c8(IF(true, empty(tail(nil)), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c9_1, c13_2, c8_1 ---------------------------------------- (65) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: WEIGHT(nil) -> c8(IF(true, empty(tail(nil)), nil)) ---------------------------------------- (66) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c9_1, c13_2, c8_1 ---------------------------------------- (67) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) We considered the (Usable) Rules: sum(nil, z0) -> z0 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) And the Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = [1] POL(IF(x_1, x_2, x_3)) = 0 POL(IF2(x_1, x_2)) = 0 POL(SUM(x_1, x_2)) = 0 POL(WEIGHT(x_1)) = x_1 POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c13(x_1, x_2)) = x_1 + x_2 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(empty(x_1)) = [1] + x_1 POL(false) = [1] POL(nil) = [1] POL(s(x_1)) = [1] + x_1 POL(sum(x_1, x_2)) = x_2 POL(tail(x_1)) = 0 POL(true) = [1] ---------------------------------------- (68) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) K tuples: WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c9_1, c13_2, c8_1 ---------------------------------------- (69) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace WEIGHT(z0) -> c9(IF(empty(z0), empty(tail(z0)), z0)) by WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(true, empty(tail(nil)), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) ---------------------------------------- (70) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(true, empty(tail(nil)), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(true, empty(tail(nil)), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) K tuples: WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, IF2_2, WEIGHT_1 Compound Symbols: c_1, c1_1, c11_1, c13_2, c8_1, c9_1 ---------------------------------------- (71) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: WEIGHT(nil) -> c9(IF(true, empty(tail(nil)), nil)) ---------------------------------------- (72) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) K tuples: WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, IF2_2, WEIGHT_1 Compound Symbols: c_1, c1_1, c11_1, c13_2, c8_1, c9_1 ---------------------------------------- (73) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) We considered the (Usable) Rules: sum(nil, z0) -> z0 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) And the Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = [1] POL(IF(x_1, x_2, x_3)) = 0 POL(IF2(x_1, x_2)) = 0 POL(SUM(x_1, x_2)) = 0 POL(WEIGHT(x_1)) = x_1 POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c13(x_1, x_2)) = x_1 + x_2 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(empty(x_1)) = [1] + x_1 POL(false) = [1] POL(nil) = [1] POL(s(x_1)) = [1] + x_1 POL(sum(x_1, x_2)) = x_2 POL(tail(x_1)) = 0 POL(true) = [1] ---------------------------------------- (74) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) K tuples: WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, IF2_2, WEIGHT_1 Compound Symbols: c_1, c1_1, c11_1, c13_2, c8_1, c9_1 ---------------------------------------- (75) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IF2(false, z0) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(z0))))), SUM(z0, cons(0, tail(tail(z0))))) by IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil)))), SUM(nil, cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil)))), SUM(nil, cons(0, tail(tail(nil))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) ---------------------------------------- (76) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil)))), SUM(nil, cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil)))), SUM(nil, cons(0, tail(tail(nil))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil)))), SUM(nil, cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil)))), SUM(nil, cons(0, tail(tail(nil))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) K tuples: WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2 ---------------------------------------- (77) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (78) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) K tuples: WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2, c13_1 ---------------------------------------- (79) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) We considered the (Usable) Rules: sum(nil, z0) -> z0 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) And the Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(IF(x_1, x_2, x_3)) = x_3 POL(IF2(x_1, x_2)) = x_2 POL(SUM(x_1, x_2)) = x_2 POL(WEIGHT(x_1)) = x_1 POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c13(x_1, x_2)) = x_1 + x_2 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(empty(x_1)) = [1] + x_1 POL(false) = [1] POL(nil) = [1] POL(s(x_1)) = 0 POL(sum(x_1, x_2)) = x_2 POL(tail(x_1)) = 0 POL(true) = [1] ---------------------------------------- (80) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) K tuples: WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2, c13_1 ---------------------------------------- (81) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) by WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(nil) -> c8(IF(true, empty(nil), nil)) ---------------------------------------- (82) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(nil) -> c8(IF(true, empty(nil), nil)) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) K tuples: WEIGHT(nil) -> c8(IF(empty(nil), empty(nil), nil)) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2, c13_1 ---------------------------------------- (83) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: WEIGHT(nil) -> c8(IF(true, empty(nil), nil)) ---------------------------------------- (84) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) K tuples: WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2, c13_1 ---------------------------------------- (85) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace WEIGHT(cons(z0, z1)) -> c8(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) by WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) ---------------------------------------- (86) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) K tuples: WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2, c13_1 ---------------------------------------- (87) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) We considered the (Usable) Rules: sum(nil, z0) -> z0 empty(nil) -> true empty(cons(z0, z1)) -> false sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) And the Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(IF(x_1, x_2, x_3)) = x_1 + x_2 POL(IF2(x_1, x_2)) = [1] + x_1 POL(SUM(x_1, x_2)) = 0 POL(WEIGHT(x_1)) = [1] + x_1 POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c13(x_1, x_2)) = x_1 + x_2 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = [1] POL(empty(x_1)) = [1] POL(false) = [1] POL(nil) = [1] POL(s(x_1)) = 0 POL(sum(x_1, x_2)) = x_2 POL(tail(x_1)) = 0 POL(true) = 0 ---------------------------------------- (88) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) K tuples: WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2, c13_1 ---------------------------------------- (89) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) by WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) ---------------------------------------- (90) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) K tuples: WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c9_1, c13_2, c13_1, c8_1 ---------------------------------------- (91) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) by WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(nil) -> c9(IF(true, empty(nil), nil)) ---------------------------------------- (92) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(nil) -> c9(IF(true, empty(nil), nil)) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) K tuples: WEIGHT(nil) -> c9(IF(empty(nil), empty(nil), nil)) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c9_1, c13_2, c13_1, c8_1 ---------------------------------------- (93) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: WEIGHT(nil) -> c9(IF(true, empty(nil), nil)) ---------------------------------------- (94) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c9_1, c13_2, c13_1, c8_1 ---------------------------------------- (95) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace WEIGHT(cons(z0, z1)) -> c9(IF(empty(cons(z0, z1)), empty(z1), cons(z0, z1))) by WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) ---------------------------------------- (96) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c9_1, c13_2, c13_1, c8_1 ---------------------------------------- (97) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) We considered the (Usable) Rules: empty(nil) -> true empty(cons(z0, z1)) -> false And the Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(IF(x_1, x_2, x_3)) = x_2 POL(IF2(x_1, x_2)) = x_1 POL(SUM(x_1, x_2)) = x_2 POL(WEIGHT(x_1)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c13(x_1, x_2)) = x_1 + x_2 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(empty(x_1)) = [1] POL(false) = [1] POL(nil) = 0 POL(s(x_1)) = 0 POL(sum(x_1, x_2)) = [1] POL(tail(x_1)) = 0 POL(true) = 0 ---------------------------------------- (98) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c9_1, c13_2, c13_1, c8_1 ---------------------------------------- (99) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(tail(cons(z0, z1))), cons(z0, z1))) by WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) ---------------------------------------- (100) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, IF2_2, WEIGHT_1 Compound Symbols: c_1, c1_1, c11_1, c13_2, c13_1, c8_1, c9_1 ---------------------------------------- (101) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(s(z0), z1)))))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) by IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) ---------------------------------------- (102) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, IF2_2, WEIGHT_1 Compound Symbols: c_1, c1_1, c11_1, c13_2, c13_1, c8_1, c9_1 ---------------------------------------- (103) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) We considered the (Usable) Rules:none And the Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(IF(x_1, x_2, x_3)) = x_3 POL(IF2(x_1, x_2)) = x_2 POL(SUM(x_1, x_2)) = 0 POL(WEIGHT(x_1)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c13(x_1, x_2)) = x_1 + x_2 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = [1] POL(empty(x_1)) = [1] + x_1 POL(false) = 0 POL(nil) = [1] POL(s(x_1)) = 0 POL(sum(x_1, x_2)) = [1] POL(tail(x_1)) = [1] POL(true) = [1] ---------------------------------------- (104) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, IF2_2, WEIGHT_1 Compound Symbols: c_1, c1_1, c11_1, c13_2, c13_1, c8_1, c9_1 ---------------------------------------- (105) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, z0)))))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) by IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) ---------------------------------------- (106) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, IF2_2, WEIGHT_1 Compound Symbols: c_1, c1_1, c11_1, c13_2, c13_1, c8_1, c9_1 ---------------------------------------- (107) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) We considered the (Usable) Rules: empty(nil) -> true empty(cons(z0, z1)) -> false And the Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(IF(x_1, x_2, x_3)) = x_1 POL(IF2(x_1, x_2)) = [1] POL(SUM(x_1, x_2)) = 0 POL(WEIGHT(x_1)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c13(x_1, x_2)) = x_1 + x_2 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = [1] POL(empty(x_1)) = x_1 POL(false) = [1] POL(nil) = 0 POL(s(x_1)) = 0 POL(sum(x_1, x_2)) = [1] POL(tail(x_1)) = [1] POL(true) = 0 ---------------------------------------- (108) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, IF2_2, WEIGHT_1 Compound Symbols: c_1, c1_1, c11_1, c13_2, c13_1, c8_1, c9_1 ---------------------------------------- (109) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IF2(false, cons(z0, z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(0, tail(z1)))), SUM(cons(z0, z1), cons(0, tail(tail(cons(z0, z1)))))) by IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) ---------------------------------------- (110) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, IF2_2, WEIGHT_1 Compound Symbols: c_1, c1_1, c11_1, c13_1, c8_1, c9_1, c13_2 ---------------------------------------- (111) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) We considered the (Usable) Rules:none And the Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(IF(x_1, x_2, x_3)) = [1] POL(IF2(x_1, x_2)) = [1] POL(SUM(x_1, x_2)) = x_2 POL(WEIGHT(x_1)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c13(x_1, x_2)) = x_1 + x_2 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(empty(x_1)) = [1] + x_1 POL(false) = 0 POL(nil) = 0 POL(s(x_1)) = 0 POL(sum(x_1, x_2)) = [1] POL(tail(x_1)) = [1] POL(true) = [1] ---------------------------------------- (112) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, IF2_2, WEIGHT_1 Compound Symbols: c_1, c1_1, c11_1, c13_1, c8_1, c9_1, c13_2 ---------------------------------------- (113) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) by IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) ---------------------------------------- (114) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, IF2_2, WEIGHT_1 Compound Symbols: c_1, c1_1, c11_1, c13_1, c8_1, c9_1, c13_2 ---------------------------------------- (115) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) by IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) ---------------------------------------- (116) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2, c13_1 ---------------------------------------- (117) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace WEIGHT(nil) -> c8(IF(empty(nil), true, nil)) by WEIGHT(nil) -> c8(IF(true, true, nil)) ---------------------------------------- (118) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) WEIGHT(nil) -> c8(IF(true, true, nil)) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) K tuples: IF2(false, nil) -> c13(WEIGHT(cons(0, tail(tail(nil))))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, tail(nil))))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2, c13_1 ---------------------------------------- (119) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: WEIGHT(nil) -> c8(IF(true, true, nil)) ---------------------------------------- (120) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2, c13_1 ---------------------------------------- (121) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace WEIGHT(nil) -> c9(IF(empty(nil), true, nil)) by WEIGHT(nil) -> c9(IF(true, true, nil)) ---------------------------------------- (122) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) WEIGHT(nil) -> c9(IF(true, true, nil)) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2, c13_1 ---------------------------------------- (123) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: WEIGHT(nil) -> c9(IF(true, true, nil)) ---------------------------------------- (124) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) IF(false, z0, z1) -> c11(IF2(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, IF_3, WEIGHT_1, IF2_2 Compound Symbols: c_1, c1_1, c11_1, c8_1, c9_1, c13_2, c13_1 ---------------------------------------- (125) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace IF(false, z0, z1) -> c11(IF2(z0, z1)) by IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, true, cons(x0, nil)) -> c11(IF2(true, cons(x0, nil))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) ---------------------------------------- (126) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, true, cons(x0, nil)) -> c11(IF2(true, cons(x0, nil))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, true, cons(x0, nil)) -> c11(IF2(true, cons(x0, nil))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (127) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IF(false, true, cons(x0, nil)) -> c11(IF2(true, cons(x0, nil))) ---------------------------------------- (128) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (129) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace WEIGHT(cons(x0, cons(z0, z1))) -> c8(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) by WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) ---------------------------------------- (130) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (131) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) by WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) ---------------------------------------- (132) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (133) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace WEIGHT(cons(x0, cons(z0, z1))) -> c9(IF(empty(cons(x0, cons(z0, z1))), false, cons(x0, cons(z0, z1)))) by WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) ---------------------------------------- (134) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (135) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) by WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) ---------------------------------------- (136) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (137) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(tail(cons(s(s(z0)), z1)))))) by IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) ---------------------------------------- (138) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (139) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(tail(cons(s(0), z0)))))) by IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) ---------------------------------------- (140) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (141) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) by IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) ---------------------------------------- (142) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (143) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) by IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) ---------------------------------------- (144) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (145) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(tail(cons(0, cons(s(z0), z1))))))) by IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) ---------------------------------------- (146) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (147) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(tail(cons(0, cons(0, z0))))))) by IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) ---------------------------------------- (148) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (149) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(tail(cons(0, nil)))))) by IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) ---------------------------------------- (150) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (151) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) by IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) ---------------------------------------- (152) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (153) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) by IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) ---------------------------------------- (154) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(s(x0), z1)) -> c13(WEIGHT(sum(cons(x0, z1), cons(s(0), tail(z1)))), SUM(cons(s(x0), z1), cons(0, tail(tail(cons(s(x0), z1)))))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (155) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(tail(cons(s(z0), z1)))))) by IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) ---------------------------------------- (156) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(0, z1)) -> c13(WEIGHT(sum(z1, cons(0, tail(z1)))), SUM(cons(0, z1), cons(0, tail(tail(cons(0, z1)))))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (157) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(tail(cons(0, z0)))))) by IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) ---------------------------------------- (158) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (159) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(x0, nil)) -> c13(WEIGHT(sum(cons(x0, nil), cons(0, nil))), SUM(cons(x0, nil), cons(0, tail(tail(cons(x0, nil)))))) by IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) ---------------------------------------- (160) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_2, c13_1, c11_1 ---------------------------------------- (161) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(x0, cons(z0, z1))) -> c13(WEIGHT(sum(cons(x0, cons(z0, z1)), cons(0, z1))), SUM(cons(x0, cons(z0, z1)), cons(0, tail(tail(cons(x0, cons(z0, z1))))))) by IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) ---------------------------------------- (162) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_1, c11_1, c13_2 ---------------------------------------- (163) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) by IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) ---------------------------------------- (164) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_1, c11_1, c13_2 ---------------------------------------- (165) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) by IF2(false, nil) -> c13(WEIGHT(cons(0, nil))) ---------------------------------------- (166) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, nil) -> c13(WEIGHT(cons(0, nil))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) K tuples: WEIGHT(cons(x0, nil)) -> c8(IF(empty(cons(x0, nil)), true, cons(x0, nil))) WEIGHT(cons(x0, nil)) -> c9(IF(empty(cons(x0, nil)), true, cons(x0, nil))) IF2(false, cons(s(x0), x1)) -> c13(SUM(cons(s(x0), x1), cons(0, tail(tail(cons(s(x0), x1)))))) IF2(false, cons(0, x0)) -> c13(SUM(cons(0, x0), cons(0, tail(tail(cons(0, x0)))))) IF2(false, cons(x0, x1)) -> c13(SUM(cons(x0, x1), cons(0, tail(tail(cons(x0, x1)))))) Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_1, c11_1, c13_2 ---------------------------------------- (167) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: IF2(false, nil) -> c13(WEIGHT(cons(0, nil))) ---------------------------------------- (168) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_1, c11_1, c13_2 ---------------------------------------- (169) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, nil) -> c13(WEIGHT(cons(0, tail(nil)))) by IF2(false, nil) -> c13(WEIGHT(cons(0, nil))) ---------------------------------------- (170) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, nil) -> c13(WEIGHT(cons(0, nil))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_1, c11_1, c13_2 ---------------------------------------- (171) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: IF2(false, nil) -> c13(WEIGHT(cons(0, nil))) ---------------------------------------- (172) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF2_2, IF_3 Compound Symbols: c_1, c1_1, c8_1, c9_1, c13_1, c11_1, c13_2 ---------------------------------------- (173) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, nil) -> c13(WEIGHT(sum(nil, cons(0, nil)))) by IF2(false, nil) -> c13(WEIGHT(cons(0, nil))) ---------------------------------------- (174) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, nil) -> c13(WEIGHT(cons(0, nil))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF_3, IF2_2 Compound Symbols: c_1, c1_1, c8_1, c9_1, c11_1, c13_2, c13_1 ---------------------------------------- (175) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: IF2(false, nil) -> c13(WEIGHT(cons(0, nil))) ---------------------------------------- (176) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF_3, IF2_2 Compound Symbols: c_1, c1_1, c8_1, c9_1, c11_1, c13_2, c13_1 ---------------------------------------- (177) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(tail(cons(s(s(z0)), z1)))))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) by IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) ---------------------------------------- (178) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF_3, IF2_2 Compound Symbols: c_1, c1_1, c8_1, c9_1, c11_1, c13_2, c13_1 ---------------------------------------- (179) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(tail(cons(s(0), z0)))))), SUM(cons(s(0), z0), cons(0, tail(z0)))) by IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) ---------------------------------------- (180) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) S tuples: SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF_3, IF2_2 Compound Symbols: c_1, c1_1, c8_1, c9_1, c11_1, c13_2, c13_1 ---------------------------------------- (181) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace SUM(cons(s(z0), z1), cons(z2, z3)) -> c(SUM(cons(z0, z1), cons(s(z2), z3))) by SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) ---------------------------------------- (182) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) S tuples: SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: SUM_2, WEIGHT_1, IF_3, IF2_2 Compound Symbols: c1_1, c8_1, c9_1, c11_1, c13_2, c13_1, c_1 ---------------------------------------- (183) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace SUM(cons(0, z0), z1) -> c1(SUM(z0, z1)) by SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) ---------------------------------------- (184) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) S tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil))))), SUM(cons(0, nil), cons(0, tail(nil)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: WEIGHT_1, IF_3, IF2_2, SUM_2 Compound Symbols: c8_1, c9_1, c11_1, c13_2, c13_1, c_1, c1_1 ---------------------------------------- (185) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (186) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil)))))) S tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil)))))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: WEIGHT_1, IF_3, IF2_2, SUM_2 Compound Symbols: c8_1, c9_1, c11_1, c13_2, c13_1, c_1, c1_1 ---------------------------------------- (187) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, tail(cons(s(z0), z1))))) by IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, z1))) ---------------------------------------- (188) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, z1))) S tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, z1))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: WEIGHT_1, IF_3, IF2_2, SUM_2 Compound Symbols: c8_1, c9_1, c11_1, c13_2, c13_1, c_1, c1_1 ---------------------------------------- (189) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, tail(cons(0, z0))))) by IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, z0))) ---------------------------------------- (190) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, z1))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, z0))) S tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, z1))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, z0))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: WEIGHT_1, IF_3, IF2_2, SUM_2 Compound Symbols: c8_1, c9_1, c11_1, c13_2, c13_1, c_1, c1_1 ---------------------------------------- (191) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, tail(nil)))) by IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, nil))) ---------------------------------------- (192) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, z1))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, z0))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, nil))) S tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, z1))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, z0))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, nil))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: WEIGHT_1, IF_3, IF2_2, SUM_2 Compound Symbols: c8_1, c9_1, c11_1, c13_2, c13_1, c_1, c1_1 ---------------------------------------- (193) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, tail(cons(z1, z2))))) by IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, z2))) ---------------------------------------- (194) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, z1))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, z0))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, nil))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, z2))) S tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil)))))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, z1))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, z0))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, nil))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, z2))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: WEIGHT_1, IF_3, IF2_2, SUM_2 Compound Symbols: c8_1, c9_1, c11_1, c13_2, c13_1, c_1, c1_1 ---------------------------------------- (195) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(tail(cons(0, nil)))))) by IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(nil)))) ---------------------------------------- (196) Obligation: Complexity Dependency Tuples Problem Rules: empty(nil) -> true empty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 sum(cons(s(z0), z1), cons(z2, z3)) -> sum(cons(z0, z1), cons(s(z2), z3)) sum(cons(0, z0), z1) -> sum(z0, z1) sum(nil, z0) -> z0 Tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c8(IF(false, true, cons(z0, nil))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, nil)) -> c9(IF(false, true, cons(z0, nil))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(s(z0), z1)) -> c13(SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(0, z0)) -> c13(SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(z0, z1)) -> c13(SUM(cons(z0, z1), cons(0, tail(z1)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, z1))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, z0))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, nil))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, z2))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(nil)))) S tuples: WEIGHT(cons(z0, z1)) -> c8(IF(false, empty(z1), cons(z0, z1))) WEIGHT(cons(z0, z1)) -> c9(IF(false, empty(z1), cons(z0, z1))) IF(false, false, cons(x0, cons(x1, x2))) -> c11(IF2(false, cons(x0, cons(x1, x2)))) IF(false, y0, cons(x0, x1)) -> c11(IF2(y0, cons(x0, x1))) WEIGHT(cons(z0, cons(z1, z2))) -> c8(IF(false, false, cons(z0, cons(z1, z2)))) WEIGHT(cons(z0, cons(z1, z2))) -> c9(IF(false, false, cons(z0, cons(z1, z2)))) IF2(false, cons(s(z0), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(z1)))), SUM(cons(s(z0), z1), cons(0, tail(z1)))) IF2(false, cons(0, z0)) -> c13(WEIGHT(sum(z0, cons(0, tail(z0)))), SUM(cons(0, z0), cons(0, tail(z0)))) IF2(false, cons(s(s(z0)), z1)) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(s(0)), tail(z1)))), SUM(cons(s(s(z0)), z1), cons(0, tail(z1)))) IF2(false, cons(s(0), z0)) -> c13(WEIGHT(sum(z0, cons(s(0), tail(z0)))), SUM(cons(s(0), z0), cons(0, tail(z0)))) SUM(cons(s(s(y0)), z1), cons(z2, z3)) -> c(SUM(cons(s(y0), z1), cons(s(z2), z3))) SUM(cons(s(0), z1), cons(z2, z3)) -> c(SUM(cons(0, z1), cons(s(z2), z3))) SUM(cons(0, cons(0, y0)), z1) -> c1(SUM(cons(0, y0), z1)) SUM(cons(0, cons(s(s(y0)), y1)), cons(y2, y3)) -> c1(SUM(cons(s(s(y0)), y1), cons(y2, y3))) SUM(cons(0, cons(s(0), y0)), cons(y1, y2)) -> c1(SUM(cons(s(0), y0), cons(y1, y2))) IF2(false, cons(0, cons(s(z0), z1))) -> c13(WEIGHT(sum(cons(z0, z1), cons(s(0), tail(tail(cons(0, cons(s(z0), z1))))))), SUM(cons(0, cons(s(z0), z1)), cons(0, z1))) IF2(false, cons(0, cons(0, z0))) -> c13(WEIGHT(sum(z0, cons(0, tail(tail(cons(0, cons(0, z0))))))), SUM(cons(0, cons(0, z0)), cons(0, z0))) IF2(false, cons(z0, nil)) -> c13(WEIGHT(sum(cons(z0, nil), cons(0, nil))), SUM(cons(z0, nil), cons(0, nil))) IF2(false, cons(z0, cons(z1, z2))) -> c13(WEIGHT(sum(cons(z0, cons(z1, z2)), cons(0, z2))), SUM(cons(z0, cons(z1, z2)), cons(0, z2))) IF2(false, cons(0, nil)) -> c13(WEIGHT(cons(0, tail(nil)))) K tuples:none Defined Rule Symbols: empty_1, tail_1, sum_2 Defined Pair Symbols: WEIGHT_1, IF_3, IF2_2, SUM_2 Compound Symbols: c8_1, c9_1, c11_1, c13_2, c13_1, c_1, c1_1