KILLED proof of input_CkyLVSdjEg.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) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms] (16) CpxRNTS (17) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms] (18) CpxRNTS (19) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (20) CpxRNTS (21) IntTrsBoundProof [UPPER BOUND(ID), 355 ms] (22) CpxRNTS (23) IntTrsBoundProof [UPPER BOUND(ID), 163 ms] (24) CpxRNTS (25) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (26) CpxRNTS (27) IntTrsBoundProof [UPPER BOUND(ID), 51 ms] (28) CpxRNTS (29) IntTrsBoundProof [UPPER BOUND(ID), 24 ms] (30) CpxRNTS (31) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (32) CpxRNTS (33) IntTrsBoundProof [UPPER BOUND(ID), 72 ms] (34) CpxRNTS (35) IntTrsBoundProof [UPPER BOUND(ID), 6 ms] (36) CpxRNTS (37) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (38) CpxRNTS (39) IntTrsBoundProof [UPPER BOUND(ID), 130 ms] (40) CpxRNTS (41) IntTrsBoundProof [UPPER BOUND(ID), 0 ms] (42) CpxRNTS (43) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (44) CpxRNTS (45) IntTrsBoundProof [UPPER BOUND(ID), 97 ms] (46) CpxRNTS (47) IntTrsBoundProof [UPPER BOUND(ID), 32 ms] (48) CpxRNTS (49) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (50) CpxRNTS (51) IntTrsBoundProof [UPPER BOUND(ID), 4068 ms] (52) CpxRNTS (53) IntTrsBoundProof [UPPER BOUND(ID), 928 ms] (54) CpxRNTS (55) CompletionProof [UPPER BOUND(ID), 0 ms] (56) CpxTypedWeightedCompleteTrs (57) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms] (58) CpxRNTS (59) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms] (60) CdtProblem (61) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (62) CdtProblem (63) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (64) CdtProblem (65) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (66) CdtProblem (67) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (68) CdtProblem (69) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (70) CdtProblem (71) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (72) CdtProblem (73) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (74) CdtProblem (75) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (76) CdtProblem (77) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (78) CdtProblem (79) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (80) CdtProblem (81) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 37 ms] (82) CdtProblem (83) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (84) CdtProblem (85) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (86) CdtProblem (87) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (88) CdtProblem (89) CdtLeafRemovalProof [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) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (98) CdtProblem (99) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (100) CdtProblem (101) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (102) CdtProblem (103) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (104) CdtProblem (105) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 41 ms] (106) CdtProblem (107) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (108) CdtProblem (109) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (110) CdtProblem (111) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (112) CdtProblem (113) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (114) CdtProblem (115) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 36 ms] (116) CdtProblem (117) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (118) CdtProblem (119) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (120) CdtProblem (121) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (122) CdtProblem (123) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (124) CdtProblem (125) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (126) CdtProblem (127) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (128) CdtProblem (129) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (130) CdtProblem (131) CdtRewritingProof [BOTH BOUNDS(ID, ID), 1 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) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (140) CdtProblem (141) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (142) CdtProblem (143) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (144) CdtProblem (145) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (146) CdtProblem (147) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (148) CdtProblem (149) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (150) CdtProblem (151) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (152) CdtProblem (153) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (154) CdtProblem (155) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (156) CdtProblem (157) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (158) CdtProblem (159) CdtInstantiationProof [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) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (166) CdtProblem (167) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (168) CdtProblem (169) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (170) CdtProblem (171) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (172) CdtProblem (173) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (174) CdtProblem (175) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (176) CdtProblem (177) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (178) CdtProblem (179) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (180) CdtProblem (181) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (182) CdtProblem (183) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (184) CdtProblem (185) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (186) CdtProblem (187) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (188) CdtProblem (189) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (190) CdtProblem (191) CdtLeafRemovalProof [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: plus(x, y) -> plusIter(x, y, 0) plusIter(x, y, z) -> ifPlus(le(x, z), x, y, z) ifPlus(true, x, y, z) -> y ifPlus(false, x, y, z) -> plusIter(x, s(y), s(z)) le(s(x), 0) -> false le(0, y) -> true le(s(x), s(y)) -> le(x, y) sum(xs) -> sumIter(xs, 0) sumIter(xs, x) -> ifSum(isempty(xs), xs, x, plus(x, head(xs))) ifSum(true, xs, x, y) -> x ifSum(false, xs, x, y) -> sumIter(tail(xs), y) isempty(nil) -> true isempty(cons(x, xs)) -> false head(nil) -> error head(cons(x, xs)) -> x tail(nil) -> nil tail(cons(x, xs)) -> xs a -> b a -> c S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (1) RenamingProof (BOTH BOUNDS(ID, ID)) Renamed function symbols to avoid clashes with predefined symbol. ---------------------------------------- (2) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: plus(x, y) -> plusIter(x, y, 0') plusIter(x, y, z) -> ifPlus(le(x, z), x, y, z) ifPlus(true, x, y, z) -> y ifPlus(false, x, y, z) -> plusIter(x, s(y), s(z)) le(s(x), 0') -> false le(0', y) -> true le(s(x), s(y)) -> le(x, y) sum(xs) -> sumIter(xs, 0') sumIter(xs, x) -> ifSum(isempty(xs), xs, x, plus(x, head(xs))) ifSum(true, xs, x, y) -> x ifSum(false, xs, x, y) -> sumIter(tail(xs), y) isempty(nil) -> true isempty(cons(x, xs)) -> false head(nil) -> error head(cons(x, xs)) -> x tail(nil) -> nil tail(cons(x, xs)) -> xs a -> b a -> c S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (3) RelTrsToTrsProof (UPPER BOUND(ID)) transformed relative TRS to TRS ---------------------------------------- (4) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: plus(x, y) -> plusIter(x, y, 0) plusIter(x, y, z) -> ifPlus(le(x, z), x, y, z) ifPlus(true, x, y, z) -> y ifPlus(false, x, y, z) -> plusIter(x, s(y), s(z)) le(s(x), 0) -> false le(0, y) -> true le(s(x), s(y)) -> le(x, y) sum(xs) -> sumIter(xs, 0) sumIter(xs, x) -> ifSum(isempty(xs), xs, x, plus(x, head(xs))) ifSum(true, xs, x, y) -> x ifSum(false, xs, x, y) -> sumIter(tail(xs), y) isempty(nil) -> true isempty(cons(x, xs)) -> false head(nil) -> error head(cons(x, xs)) -> x tail(nil) -> nil tail(cons(x, xs)) -> xs a -> b a -> c S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (5) RelTrsToWeightedTrsProof (UPPER BOUND(ID)) Transformed relative TRS to weighted TRS ---------------------------------------- (6) Obligation: The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: plus(x, y) -> plusIter(x, y, 0) [1] plusIter(x, y, z) -> ifPlus(le(x, z), x, y, z) [1] ifPlus(true, x, y, z) -> y [1] ifPlus(false, x, y, z) -> plusIter(x, s(y), s(z)) [1] le(s(x), 0) -> false [1] le(0, y) -> true [1] le(s(x), s(y)) -> le(x, y) [1] sum(xs) -> sumIter(xs, 0) [1] sumIter(xs, x) -> ifSum(isempty(xs), xs, x, plus(x, head(xs))) [1] ifSum(true, xs, x, y) -> x [1] ifSum(false, xs, x, y) -> sumIter(tail(xs), y) [1] isempty(nil) -> true [1] isempty(cons(x, xs)) -> false [1] head(nil) -> error [1] head(cons(x, xs)) -> x [1] tail(nil) -> nil [1] tail(cons(x, xs)) -> xs [1] a -> b [1] a -> c [1] Rewrite Strategy: INNERMOST ---------------------------------------- (7) TypeInferenceProof (BOTH BOUNDS(ID, ID)) Infered types. ---------------------------------------- (8) Obligation: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: plus(x, y) -> plusIter(x, y, 0) [1] plusIter(x, y, z) -> ifPlus(le(x, z), x, y, z) [1] ifPlus(true, x, y, z) -> y [1] ifPlus(false, x, y, z) -> plusIter(x, s(y), s(z)) [1] le(s(x), 0) -> false [1] le(0, y) -> true [1] le(s(x), s(y)) -> le(x, y) [1] sum(xs) -> sumIter(xs, 0) [1] sumIter(xs, x) -> ifSum(isempty(xs), xs, x, plus(x, head(xs))) [1] ifSum(true, xs, x, y) -> x [1] ifSum(false, xs, x, y) -> sumIter(tail(xs), y) [1] isempty(nil) -> true [1] isempty(cons(x, xs)) -> false [1] head(nil) -> error [1] head(cons(x, xs)) -> x [1] tail(nil) -> nil [1] tail(cons(x, xs)) -> xs [1] a -> b [1] a -> c [1] The TRS has the following type information: plus :: 0:s:error -> 0:s:error -> 0:s:error plusIter :: 0:s:error -> 0:s:error -> 0:s:error -> 0:s:error 0 :: 0:s:error ifPlus :: true:false -> 0:s:error -> 0:s:error -> 0:s:error -> 0:s:error le :: 0:s:error -> 0:s:error -> true:false true :: true:false false :: true:false s :: 0:s:error -> 0:s:error sum :: nil:cons -> 0:s:error sumIter :: nil:cons -> 0:s:error -> 0:s:error ifSum :: true:false -> nil:cons -> 0:s:error -> 0:s:error -> 0:s:error isempty :: nil:cons -> true:false head :: nil:cons -> 0:s:error tail :: nil:cons -> nil:cons nil :: nil:cons cons :: 0:s:error -> nil:cons -> nil:cons error :: 0:s:error a :: b:c b :: b:c c :: b:c Rewrite Strategy: INNERMOST ---------------------------------------- (9) CompletionProof (UPPER BOUND(ID)) The transformation into a RNTS is sound, since: (a) The obligation is a constructor system where every type has a constant constructor, (b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols: sum_1 sumIter_2 ifSum_4 a (c) The following functions are completely defined: le_2 isempty_1 plus_2 head_1 tail_1 plusIter_3 ifPlus_4 Due to the following rules being added: le(v0, v1) -> null_le [0] ifPlus(v0, v1, v2, v3) -> null_ifPlus [0] And the following fresh constants: null_le, null_ifPlus ---------------------------------------- (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: plus(x, y) -> plusIter(x, y, 0) [1] plusIter(x, y, z) -> ifPlus(le(x, z), x, y, z) [1] ifPlus(true, x, y, z) -> y [1] ifPlus(false, x, y, z) -> plusIter(x, s(y), s(z)) [1] le(s(x), 0) -> false [1] le(0, y) -> true [1] le(s(x), s(y)) -> le(x, y) [1] sum(xs) -> sumIter(xs, 0) [1] sumIter(xs, x) -> ifSum(isempty(xs), xs, x, plus(x, head(xs))) [1] ifSum(true, xs, x, y) -> x [1] ifSum(false, xs, x, y) -> sumIter(tail(xs), y) [1] isempty(nil) -> true [1] isempty(cons(x, xs)) -> false [1] head(nil) -> error [1] head(cons(x, xs)) -> x [1] tail(nil) -> nil [1] tail(cons(x, xs)) -> xs [1] a -> b [1] a -> c [1] le(v0, v1) -> null_le [0] ifPlus(v0, v1, v2, v3) -> null_ifPlus [0] The TRS has the following type information: plus :: 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus plusIter :: 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus 0 :: 0:s:error:null_ifPlus ifPlus :: true:false:null_le -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus le :: 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> true:false:null_le true :: true:false:null_le false :: true:false:null_le s :: 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus sum :: nil:cons -> 0:s:error:null_ifPlus sumIter :: nil:cons -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus ifSum :: true:false:null_le -> nil:cons -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus isempty :: nil:cons -> true:false:null_le head :: nil:cons -> 0:s:error:null_ifPlus tail :: nil:cons -> nil:cons nil :: nil:cons cons :: 0:s:error:null_ifPlus -> nil:cons -> nil:cons error :: 0:s:error:null_ifPlus a :: b:c b :: b:c c :: b:c null_le :: true:false:null_le null_ifPlus :: 0:s:error:null_ifPlus 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: plus(x, y) -> plusIter(x, y, 0) [1] plusIter(s(x'), y, 0) -> ifPlus(false, s(x'), y, 0) [2] plusIter(0, y, z) -> ifPlus(true, 0, y, z) [2] plusIter(s(x''), y, s(y')) -> ifPlus(le(x'', y'), s(x''), y, s(y')) [2] plusIter(x, y, z) -> ifPlus(null_le, x, y, z) [1] ifPlus(true, x, y, z) -> y [1] ifPlus(false, x, y, z) -> plusIter(x, s(y), s(z)) [1] le(s(x), 0) -> false [1] le(0, y) -> true [1] le(s(x), s(y)) -> le(x, y) [1] sum(xs) -> sumIter(xs, 0) [1] sumIter(nil, x) -> ifSum(true, nil, x, plus(x, error)) [3] sumIter(cons(x1, xs'), x) -> ifSum(false, cons(x1, xs'), x, plus(x, x1)) [3] ifSum(true, xs, x, y) -> x [1] ifSum(false, nil, x, y) -> sumIter(nil, y) [2] ifSum(false, cons(x2, xs''), x, y) -> sumIter(xs'', y) [2] isempty(nil) -> true [1] isempty(cons(x, xs)) -> false [1] head(nil) -> error [1] head(cons(x, xs)) -> x [1] tail(nil) -> nil [1] tail(cons(x, xs)) -> xs [1] a -> b [1] a -> c [1] le(v0, v1) -> null_le [0] ifPlus(v0, v1, v2, v3) -> null_ifPlus [0] The TRS has the following type information: plus :: 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus plusIter :: 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus 0 :: 0:s:error:null_ifPlus ifPlus :: true:false:null_le -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus le :: 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> true:false:null_le true :: true:false:null_le false :: true:false:null_le s :: 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus sum :: nil:cons -> 0:s:error:null_ifPlus sumIter :: nil:cons -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus ifSum :: true:false:null_le -> nil:cons -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus -> 0:s:error:null_ifPlus isempty :: nil:cons -> true:false:null_le head :: nil:cons -> 0:s:error:null_ifPlus tail :: nil:cons -> nil:cons nil :: nil:cons cons :: 0:s:error:null_ifPlus -> nil:cons -> nil:cons error :: 0:s:error:null_ifPlus a :: b:c b :: b:c c :: b:c null_le :: true:false:null_le null_ifPlus :: 0:s:error:null_ifPlus 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 true => 2 false => 1 nil => 0 error => 1 b => 0 c => 1 null_le => 0 null_ifPlus => 0 ---------------------------------------- (14) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> y :|: z1 = y, z >= 0, z' = 2, z2 = z, x >= 0, y >= 0, z'' = x ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(x, 1 + y, 1 + z) :|: z1 = y, z >= 0, z2 = z, x >= 0, y >= 0, z'' = x, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z2 = v3, v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, v3 >= 0, z' = v0 ifSum(z', z'', z1, z2) -{ 1 }-> x :|: xs >= 0, z2 = y, z' = 2, x >= 0, y >= 0, z'' = xs, z1 = x ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', y) :|: z2 = y, z'' = 1 + x2 + xs'', xs'' >= 0, x >= 0, y >= 0, z' = 1, z1 = x, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, y) :|: z'' = 0, z2 = y, x >= 0, y >= 0, z' = 1, z1 = x isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 1 }-> le(x, y) :|: z' = 1 + x, x >= 0, y >= 0, z'' = 1 + y le(z', z'') -{ 1 }-> 2 :|: z'' = y, y >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 1 + x, x >= 0 le(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0 plus(z', z'') -{ 1 }-> plusIter(x, y, 0) :|: z' = x, z'' = y, x >= 0, y >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(le(x'', y'), 1 + x'', y, 1 + y') :|: z' = 1 + x'', z'' = y, y >= 0, z1 = 1 + y', y' >= 0, x'' >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, y, z) :|: z1 = z, z >= 0, z'' = y, y >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + x', y, 0) :|: z1 = 0, z' = 1 + x', z'' = y, x' >= 0, y >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, x, y, z) :|: z1 = z, z >= 0, z' = x, z'' = y, x >= 0, y >= 0 sum(z') -{ 1 }-> sumIter(xs, 0) :|: xs >= 0, z' = xs sumIter(z', z'') -{ 3 }-> ifSum(2, 0, x, plus(x, 1)) :|: x >= 0, z'' = x, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', x, plus(x, x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, x >= 0, z'' = x tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 ---------------------------------------- (15) SimplificationProof (BOTH BOUNDS(ID, ID)) Simplified the RNTS by moving equalities from the constraints into the right-hand sides. ---------------------------------------- (16) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(le(z' - 1, z1 - 1), 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 ---------------------------------------- (17) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID)) Found the following analysis order by SCC decomposition: { le } { tail } { isempty } { head } { a } { plusIter, ifPlus } { plus } { ifSum, sumIter } { sum } ---------------------------------------- (18) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(le(z' - 1, z1 - 1), 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {le}, {tail}, {isempty}, {head}, {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} ---------------------------------------- (19) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (20) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(le(z' - 1, z1 - 1), 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {le}, {tail}, {isempty}, {head}, {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} ---------------------------------------- (21) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: le after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 2 ---------------------------------------- (22) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(le(z' - 1, z1 - 1), 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {le}, {tail}, {isempty}, {head}, {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: ?, size: O(1) [2] ---------------------------------------- (23) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using KoAT for: le after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 2 + z'' ---------------------------------------- (24) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(le(z' - 1, z1 - 1), 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {tail}, {isempty}, {head}, {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] ---------------------------------------- (25) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (26) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {tail}, {isempty}, {head}, {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] ---------------------------------------- (27) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: tail after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z' ---------------------------------------- (28) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {tail}, {isempty}, {head}, {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: ?, size: O(n^1) [z'] ---------------------------------------- (29) 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 ---------------------------------------- (30) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {isempty}, {head}, {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] ---------------------------------------- (31) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (32) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {isempty}, {head}, {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] ---------------------------------------- (33) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: isempty after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 2 ---------------------------------------- (34) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {isempty}, {head}, {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: ?, size: O(1) [2] ---------------------------------------- (35) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: isempty after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (36) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {head}, {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ---------------------------------------- (37) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (38) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {head}, {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ---------------------------------------- (39) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: head after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z' ---------------------------------------- (40) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {head}, {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] head: runtime: ?, size: O(n^1) [1 + z'] ---------------------------------------- (41) 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 ---------------------------------------- (42) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] ---------------------------------------- (43) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (44) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] ---------------------------------------- (45) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: a after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (46) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {a}, {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] a: runtime: ?, size: O(1) [1] ---------------------------------------- (47) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: a after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (48) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] a: runtime: O(1) [1], size: O(1) [1] ---------------------------------------- (49) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (50) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] a: runtime: O(1) [1], size: O(1) [1] ---------------------------------------- (51) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: plusIter after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? Computed SIZE bound using CoFloCo for: ifPlus after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (52) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] a: runtime: O(1) [1], size: O(1) [1] plusIter: runtime: ?, size: INF ifPlus: runtime: ?, size: INF ---------------------------------------- (53) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: plusIter after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (54) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> z1 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0 ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(z'', 1 + z1, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0, z2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(xs'', z2) :|: z'' = 1 + x2 + xs'', xs'' >= 0, z1 >= 0, z2 >= 0, z' = 1, x2 >= 0 ifSum(z', z'', z1, z2) -{ 2 }-> sumIter(0, z2) :|: z'' = 0, z1 >= 0, z2 >= 0, z' = 1 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 2 + z'' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0 le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> plusIter(z', z'', 0) :|: z' >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 3 + z1 }-> ifPlus(s, 1 + (z' - 1), z'', 1 + (z1 - 1)) :|: s >= 0, s <= 2, z'' >= 0, z1 - 1 >= 0, z' - 1 >= 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(2, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0 plusIter(z', z'', z1) -{ 2 }-> ifPlus(1, 1 + (z' - 1), z'', 0) :|: z1 = 0, z' - 1 >= 0, z'' >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(0, z', z'', z1) :|: z1 >= 0, z' >= 0, z'' >= 0 sum(z') -{ 1 }-> sumIter(z', 0) :|: z' >= 0 sumIter(z', z'') -{ 3 }-> ifSum(2, 0, z'', plus(z'', 1)) :|: z'' >= 0, z' = 0 sumIter(z', z'') -{ 3 }-> ifSum(1, 1 + x1 + xs', z'', plus(z'', x1)) :|: x1 >= 0, z' = 1 + x1 + xs', xs' >= 0, z'' >= 0 tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Function symbols to be analyzed: {plusIter,ifPlus}, {plus}, {ifSum,sumIter}, {sum} Previous analysis results are: le: runtime: O(n^1) [2 + z''], size: O(1) [2] tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] a: runtime: O(1) [1], size: O(1) [1] plusIter: runtime: INF, size: INF ifPlus: runtime: ?, size: INF ---------------------------------------- (55) CompletionProof (UPPER BOUND(ID)) The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added: le(v0, v1) -> null_le [0] ifPlus(v0, v1, v2, v3) -> null_ifPlus [0] ifSum(v0, v1, v2, v3) -> null_ifSum [0] And the following fresh constants: null_le, null_ifPlus, null_ifSum ---------------------------------------- (56) 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: plus(x, y) -> plusIter(x, y, 0) [1] plusIter(x, y, z) -> ifPlus(le(x, z), x, y, z) [1] ifPlus(true, x, y, z) -> y [1] ifPlus(false, x, y, z) -> plusIter(x, s(y), s(z)) [1] le(s(x), 0) -> false [1] le(0, y) -> true [1] le(s(x), s(y)) -> le(x, y) [1] sum(xs) -> sumIter(xs, 0) [1] sumIter(xs, x) -> ifSum(isempty(xs), xs, x, plus(x, head(xs))) [1] ifSum(true, xs, x, y) -> x [1] ifSum(false, xs, x, y) -> sumIter(tail(xs), y) [1] isempty(nil) -> true [1] isempty(cons(x, xs)) -> false [1] head(nil) -> error [1] head(cons(x, xs)) -> x [1] tail(nil) -> nil [1] tail(cons(x, xs)) -> xs [1] a -> b [1] a -> c [1] le(v0, v1) -> null_le [0] ifPlus(v0, v1, v2, v3) -> null_ifPlus [0] ifSum(v0, v1, v2, v3) -> null_ifSum [0] The TRS has the following type information: plus :: 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum plusIter :: 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum 0 :: 0:s:error:null_ifPlus:null_ifSum ifPlus :: true:false:null_le -> 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum le :: 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum -> true:false:null_le true :: true:false:null_le false :: true:false:null_le s :: 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum sum :: nil:cons -> 0:s:error:null_ifPlus:null_ifSum sumIter :: nil:cons -> 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum ifSum :: true:false:null_le -> nil:cons -> 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum -> 0:s:error:null_ifPlus:null_ifSum isempty :: nil:cons -> true:false:null_le head :: nil:cons -> 0:s:error:null_ifPlus:null_ifSum tail :: nil:cons -> nil:cons nil :: nil:cons cons :: 0:s:error:null_ifPlus:null_ifSum -> nil:cons -> nil:cons error :: 0:s:error:null_ifPlus:null_ifSum a :: b:c b :: b:c c :: b:c null_le :: true:false:null_le null_ifPlus :: 0:s:error:null_ifPlus:null_ifSum null_ifSum :: 0:s:error:null_ifPlus:null_ifSum Rewrite Strategy: INNERMOST ---------------------------------------- (57) 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 true => 2 false => 1 nil => 0 error => 1 b => 0 c => 1 null_le => 0 null_ifPlus => 0 null_ifSum => 0 ---------------------------------------- (58) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifPlus(z', z'', z1, z2) -{ 1 }-> y :|: z1 = y, z >= 0, z' = 2, z2 = z, x >= 0, y >= 0, z'' = x ifPlus(z', z'', z1, z2) -{ 1 }-> plusIter(x, 1 + y, 1 + z) :|: z1 = y, z >= 0, z2 = z, x >= 0, y >= 0, z'' = x, z' = 1 ifPlus(z', z'', z1, z2) -{ 0 }-> 0 :|: z2 = v3, v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, v3 >= 0, z' = v0 ifSum(z', z'', z1, z2) -{ 1 }-> x :|: xs >= 0, z2 = y, z' = 2, x >= 0, y >= 0, z'' = xs, z1 = x ifSum(z', z'', z1, z2) -{ 1 }-> sumIter(tail(xs), y) :|: xs >= 0, z2 = y, x >= 0, y >= 0, z'' = xs, z' = 1, z1 = x ifSum(z', z'', z1, z2) -{ 0 }-> 0 :|: z2 = v3, v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, v3 >= 0, z' = v0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 le(z', z'') -{ 1 }-> le(x, y) :|: z' = 1 + x, x >= 0, y >= 0, z'' = 1 + y le(z', z'') -{ 1 }-> 2 :|: z'' = y, y >= 0, z' = 0 le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 1 + x, x >= 0 le(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0 plus(z', z'') -{ 1 }-> plusIter(x, y, 0) :|: z' = x, z'' = y, x >= 0, y >= 0 plusIter(z', z'', z1) -{ 1 }-> ifPlus(le(x, z), x, y, z) :|: z1 = z, z >= 0, z' = x, z'' = y, x >= 0, y >= 0 sum(z') -{ 1 }-> sumIter(xs, 0) :|: xs >= 0, z' = xs sumIter(z', z'') -{ 1 }-> ifSum(isempty(xs), xs, x, plus(x, head(xs))) :|: xs >= 0, x >= 0, z'' = x, z' = xs tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 Only complete derivations are relevant for the runtime complexity. ---------------------------------------- (59) CpxTrsToCdtProof (UPPER BOUND(ID)) Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT ---------------------------------------- (60) Obligation: Complexity Dependency Tuples Problem Rules: plus(z0, z1) -> plusIter(z0, z1, 0) plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) sum(z0) -> sumIter(z0, 0) sumIter(z0, z1) -> ifSum(isempty(z0), z0, z1, plus(z1, head(z0))) ifSum(true, z0, z1, z2) -> z1 ifSum(false, z0, z1, z2) -> sumIter(tail(z0), z2) isempty(nil) -> true isempty(cons(z0, z1)) -> false head(nil) -> error head(cons(z0, z1)) -> z0 tail(nil) -> nil tail(cons(z0, z1)) -> z1 a -> b a -> c Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) PLUSITER(z0, z1, z2) -> c2(IFPLUS(le(z0, z2), z0, z1, z2), LE(z0, z2)) IFPLUS(true, z0, z1, z2) -> c3 IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), 0) -> c5 LE(0, z0) -> c6 LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUM(z0) -> c8(SUMITER(z0, 0)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), ISEMPTY(z0)) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0)), HEAD(z0)) IFSUM(true, z0, z1, z2) -> c11 IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2), TAIL(z0)) ISEMPTY(nil) -> c13 ISEMPTY(cons(z0, z1)) -> c14 HEAD(nil) -> c15 HEAD(cons(z0, z1)) -> c16 TAIL(nil) -> c17 TAIL(cons(z0, z1)) -> c18 A -> c19 A -> c20 S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) PLUSITER(z0, z1, z2) -> c2(IFPLUS(le(z0, z2), z0, z1, z2), LE(z0, z2)) IFPLUS(true, z0, z1, z2) -> c3 IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), 0) -> c5 LE(0, z0) -> c6 LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUM(z0) -> c8(SUMITER(z0, 0)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), ISEMPTY(z0)) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0)), HEAD(z0)) IFSUM(true, z0, z1, z2) -> c11 IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2), TAIL(z0)) ISEMPTY(nil) -> c13 ISEMPTY(cons(z0, z1)) -> c14 HEAD(nil) -> c15 HEAD(cons(z0, z1)) -> c16 TAIL(nil) -> c17 TAIL(cons(z0, z1)) -> c18 A -> c19 A -> c20 K tuples:none Defined Rule Symbols: plus_2, plusIter_3, ifPlus_4, le_2, sum_1, sumIter_2, ifSum_4, isempty_1, head_1, tail_1, a Defined Pair Symbols: PLUS_2, PLUSITER_3, IFPLUS_4, LE_2, SUM_1, SUMITER_2, IFSUM_4, ISEMPTY_1, HEAD_1, TAIL_1, A Compound Symbols: c1_1, c2_2, c3, c4_1, c5, c6, c7_1, c8_1, c9_2, c10_3, c11, c12_2, c13, c14, c15, c16, c17, c18, c19, c20 ---------------------------------------- (61) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: SUM(z0) -> c8(SUMITER(z0, 0)) Removed 12 trailing nodes: IFSUM(true, z0, z1, z2) -> c11 IFPLUS(true, z0, z1, z2) -> c3 TAIL(nil) -> c17 ISEMPTY(nil) -> c13 LE(s(z0), 0) -> c5 HEAD(cons(z0, z1)) -> c16 LE(0, z0) -> c6 A -> c20 A -> c19 TAIL(cons(z0, z1)) -> c18 HEAD(nil) -> c15 ISEMPTY(cons(z0, z1)) -> c14 ---------------------------------------- (62) Obligation: Complexity Dependency Tuples Problem Rules: plus(z0, z1) -> plusIter(z0, z1, 0) plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) sum(z0) -> sumIter(z0, 0) sumIter(z0, z1) -> ifSum(isempty(z0), z0, z1, plus(z1, head(z0))) ifSum(true, z0, z1, z2) -> z1 ifSum(false, z0, z1, z2) -> sumIter(tail(z0), z2) isempty(nil) -> true isempty(cons(z0, z1)) -> false head(nil) -> error head(cons(z0, z1)) -> z0 tail(nil) -> nil tail(cons(z0, z1)) -> z1 a -> b a -> c Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) PLUSITER(z0, z1, z2) -> c2(IFPLUS(le(z0, z2), z0, z1, z2), LE(z0, z2)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), ISEMPTY(z0)) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0)), HEAD(z0)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2), TAIL(z0)) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) PLUSITER(z0, z1, z2) -> c2(IFPLUS(le(z0, z2), z0, z1, z2), LE(z0, z2)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), ISEMPTY(z0)) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0)), HEAD(z0)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2), TAIL(z0)) K tuples:none Defined Rule Symbols: plus_2, plusIter_3, ifPlus_4, le_2, sum_1, sumIter_2, ifSum_4, isempty_1, head_1, tail_1, a Defined Pair Symbols: PLUS_2, PLUSITER_3, IFPLUS_4, LE_2, SUMITER_2, IFSUM_4 Compound Symbols: c1_1, c2_2, c4_1, c7_1, c9_2, c10_3, c12_2 ---------------------------------------- (63) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 3 trailing tuple parts ---------------------------------------- (64) Obligation: Complexity Dependency Tuples Problem Rules: plus(z0, z1) -> plusIter(z0, z1, 0) plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) sum(z0) -> sumIter(z0, 0) sumIter(z0, z1) -> ifSum(isempty(z0), z0, z1, plus(z1, head(z0))) ifSum(true, z0, z1, z2) -> z1 ifSum(false, z0, z1, z2) -> sumIter(tail(z0), z2) isempty(nil) -> true isempty(cons(z0, z1)) -> false head(nil) -> error head(cons(z0, z1)) -> z0 tail(nil) -> nil tail(cons(z0, z1)) -> z1 a -> b a -> c Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) PLUSITER(z0, z1, z2) -> c2(IFPLUS(le(z0, z2), z0, z1, z2), LE(z0, z2)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0)))) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) PLUSITER(z0, z1, z2) -> c2(IFPLUS(le(z0, z2), z0, z1, z2), LE(z0, z2)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0)))) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) K tuples:none Defined Rule Symbols: plus_2, plusIter_3, ifPlus_4, le_2, sum_1, sumIter_2, ifSum_4, isempty_1, head_1, tail_1, a Defined Pair Symbols: PLUS_2, PLUSITER_3, IFPLUS_4, LE_2, SUMITER_2, IFSUM_4 Compound Symbols: c1_1, c2_2, c4_1, c7_1, c9_1, c10_2, c12_1 ---------------------------------------- (65) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: sum(z0) -> sumIter(z0, 0) sumIter(z0, z1) -> ifSum(isempty(z0), z0, z1, plus(z1, head(z0))) ifSum(true, z0, z1, z2) -> z1 ifSum(false, z0, z1, z2) -> sumIter(tail(z0), z2) a -> b a -> c ---------------------------------------- (66) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) PLUSITER(z0, z1, z2) -> c2(IFPLUS(le(z0, z2), z0, z1, z2), LE(z0, z2)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0)))) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) PLUSITER(z0, z1, z2) -> c2(IFPLUS(le(z0, z2), z0, z1, z2), LE(z0, z2)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0)))) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) K tuples:none Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, PLUSITER_3, IFPLUS_4, LE_2, SUMITER_2, IFSUM_4 Compound Symbols: c1_1, c2_2, c4_1, c7_1, c9_1, c10_2, c12_1 ---------------------------------------- (67) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace PLUSITER(z0, z1, z2) -> c2(IFPLUS(le(z0, z2), z0, z1, z2), LE(z0, z2)) by PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0), LE(s(z0), 0)) PLUSITER(0, x1, z0) -> c2(IFPLUS(true, 0, x1, z0), LE(0, z0)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) ---------------------------------------- (68) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0)))) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0), LE(s(z0), 0)) PLUSITER(0, x1, z0) -> c2(IFPLUS(true, 0, x1, z0), LE(0, z0)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0)))) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0), LE(s(z0), 0)) PLUSITER(0, x1, z0) -> c2(IFPLUS(true, 0, x1, z0), LE(0, z0)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) K tuples:none Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, SUMITER_2, IFSUM_4, PLUSITER_3 Compound Symbols: c1_1, c4_1, c7_1, c9_1, c10_2, c12_1, c2_2 ---------------------------------------- (69) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: PLUSITER(0, x1, z0) -> c2(IFPLUS(true, 0, x1, z0), LE(0, z0)) ---------------------------------------- (70) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0)))) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0), LE(s(z0), 0)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0)))) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0), LE(s(z0), 0)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) K tuples:none Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, SUMITER_2, IFSUM_4, PLUSITER_3 Compound Symbols: c1_1, c4_1, c7_1, c9_1, c10_2, c12_1, c2_2 ---------------------------------------- (71) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (72) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0)))) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0)))) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) K tuples:none Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, SUMITER_2, IFSUM_4, PLUSITER_3 Compound Symbols: c1_1, c4_1, c7_1, c9_1, c10_2, c12_1, c2_2, c2_1 ---------------------------------------- (73) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SUMITER(z0, z1) -> c9(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0)))) by SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(nil, x1) -> c9(IFSUM(true, nil, x1, plus(x1, head(nil)))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) ---------------------------------------- (74) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(nil, x1) -> c9(IFSUM(true, nil, x1, plus(x1, head(nil)))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(nil, x1) -> c9(IFSUM(true, nil, x1, plus(x1, head(nil)))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) K tuples:none Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, SUMITER_2, IFSUM_4, PLUSITER_3 Compound Symbols: c1_1, c4_1, c7_1, c10_2, c12_1, c2_2, c2_1, c9_1 ---------------------------------------- (75) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: SUMITER(nil, x1) -> c9(IFSUM(true, nil, x1, plus(x1, head(nil)))) ---------------------------------------- (76) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) K tuples:none Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, SUMITER_2, IFSUM_4, PLUSITER_3 Compound Symbols: c1_1, c4_1, c7_1, c10_2, c12_1, c2_2, c2_1, c9_1 ---------------------------------------- (77) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SUMITER(z0, z1) -> c10(IFSUM(isempty(z0), z0, z1, plus(z1, head(z0))), PLUS(z1, head(z0))) by SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(IFSUM(true, nil, x1, plus(x1, head(nil))), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) ---------------------------------------- (78) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(IFSUM(true, nil, x1, plus(x1, head(nil))), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(IFSUM(true, nil, x1, plus(x1, head(nil))), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) K tuples:none Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_2, c2_1, c9_1, c10_2 ---------------------------------------- (79) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (80) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) K tuples:none Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_2, c2_1, c9_1, c10_2, c10_1 ---------------------------------------- (81) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) We considered the (Usable) Rules: tail(cons(z0, z1)) -> z1 isempty(nil) -> true tail(nil) -> nil isempty(cons(z0, z1)) -> false And the Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(IFPLUS(x_1, x_2, x_3, x_4)) = x_2 POL(IFSUM(x_1, x_2, x_3, x_4)) = x_1 + x_2 POL(LE(x_1, x_2)) = 0 POL(PLUS(x_1, x_2)) = 0 POL(PLUSITER(x_1, x_2, x_3)) = x_3 POL(SUMITER(x_1, x_2)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c2(x_1)) = x_1 POL(c2(x_1, x_2)) = x_1 + x_2 POL(c4(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = x_1 + x_2 POL(error) = 0 POL(false) = 0 POL(head(x_1)) = 0 POL(ifPlus(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4 POL(isempty(x_1)) = 0 POL(le(x_1, x_2)) = [1] + x_1 + x_2 POL(nil) = [1] POL(plus(x_1, x_2)) = [1] + x_1 + x_2 POL(plusIter(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3 POL(s(x_1)) = 0 POL(tail(x_1)) = x_1 POL(true) = 0 ---------------------------------------- (82) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_2, c2_1, c9_1, c10_2, c10_1 ---------------------------------------- (83) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace PLUSITER(s(z0), x1, s(z1)) -> c2(IFPLUS(le(z0, z1), s(z0), x1, s(z1)), LE(s(z0), s(z1))) by PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(0), x1, s(z0)) -> c2(IFPLUS(true, s(0), x1, s(z0)), LE(s(0), s(z0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) ---------------------------------------- (84) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(0), x1, s(z0)) -> c2(IFPLUS(true, s(0), x1, s(z0)), LE(s(0), s(z0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(0), x1, s(z0)) -> c2(IFPLUS(true, s(0), x1, s(z0)), LE(s(0), s(z0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c2_2 ---------------------------------------- (85) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (86) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c2_2 ---------------------------------------- (87) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0))) by SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(nil, x1) -> c9(IFSUM(true, nil, x1, plusIter(x1, head(nil), 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) ---------------------------------------- (88) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(nil, x1) -> c9(IFSUM(true, nil, x1, plusIter(x1, head(nil), 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(nil, x1) -> c9(IFSUM(true, nil, x1, plusIter(x1, head(nil), 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c2_2 ---------------------------------------- (89) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: SUMITER(nil, x1) -> c9(IFSUM(true, nil, x1, plusIter(x1, head(nil), 0))) ---------------------------------------- (90) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c2_2 ---------------------------------------- (91) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plus(x1, error))) by SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0))) SUMITER(nil, x0) -> c9(IFSUM(true, nil, x0, plus(x0, error))) ---------------------------------------- (92) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(nil, x0) -> c9(IFSUM(true, nil, x0, plus(x0, error))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(nil, x0) -> c9(IFSUM(true, nil, x0, plus(x0, error))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c2_2 ---------------------------------------- (93) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: SUMITER(nil, x0) -> c9(IFSUM(true, nil, x0, plus(x0, error))) ---------------------------------------- (94) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c2_2 ---------------------------------------- (95) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0))) by SUMITER(cons(z1, x1), z0) -> c9(IFSUM(isempty(cons(z1, x1)), cons(z1, x1), z0, plusIter(z0, z1, 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) ---------------------------------------- (96) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c2_2 ---------------------------------------- (97) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1))))) by SUMITER(cons(x0, x1), z0) -> c9(IFSUM(false, cons(x0, x1), z0, plusIter(z0, head(cons(x0, x1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) ---------------------------------------- (98) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_2, c10_1, c2_2, c9_1 ---------------------------------------- (99) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, plusIter(z0, head(x0), 0)), PLUS(z0, head(x0))) by SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(IFSUM(true, nil, x1, plusIter(x1, head(nil), 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) ---------------------------------------- (100) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(IFSUM(true, nil, x1, plusIter(x1, head(nil), 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(IFSUM(true, nil, x1, plusIter(x1, head(nil), 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_2, c10_1, c2_2, c9_1 ---------------------------------------- (101) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (102) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_2, c10_1, c2_2, c9_1 ---------------------------------------- (103) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) ---------------------------------------- (104) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_2, c10_1, c2_2, c9_1 ---------------------------------------- (105) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) We considered the (Usable) Rules: isempty(nil) -> true isempty(cons(z0, z1)) -> false And the Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(IFPLUS(x_1, x_2, x_3, x_4)) = x_2 POL(IFSUM(x_1, x_2, x_3, x_4)) = x_1 POL(LE(x_1, x_2)) = 0 POL(PLUS(x_1, x_2)) = 0 POL(PLUSITER(x_1, x_2, x_3)) = x_3 POL(SUMITER(x_1, x_2)) = [1] POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c2(x_1)) = x_1 POL(c2(x_1, x_2)) = x_1 + x_2 POL(c4(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = x_2 POL(error) = 0 POL(false) = [1] POL(head(x_1)) = 0 POL(ifPlus(x_1, x_2, x_3, x_4)) = [1] + x_2 + x_4 POL(isempty(x_1)) = [1] POL(le(x_1, x_2)) = x_1 POL(nil) = 0 POL(plus(x_1, x_2)) = [1] + x_1 POL(plusIter(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3 POL(s(x_1)) = 0 POL(tail(x_1)) = [1] + x_1 POL(true) = [1] ---------------------------------------- (106) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_2, c10_1, c2_2, c9_1 ---------------------------------------- (107) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plus(x1, error)), PLUS(x1, head(nil))) by SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, head(nil))) SUMITER(nil, x0) -> c10(IFSUM(true, nil, x0, plus(x0, error)), PLUS(x0, head(nil))) ---------------------------------------- (108) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(nil, x0) -> c10(IFSUM(true, nil, x0, plus(x0, error)), PLUS(x0, head(nil))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x0) -> c10(IFSUM(true, nil, x0, plus(x0, error)), PLUS(x0, head(nil))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_2, c10_1, c2_2, c9_1 ---------------------------------------- (109) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (110) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x0) -> c10(PLUS(x0, head(nil))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_2, c10_1, c2_2, c9_1 ---------------------------------------- (111) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(nil, x0) -> c10(PLUS(x0, head(nil))) ---------------------------------------- (112) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_2, c10_1, c2_2, c9_1 ---------------------------------------- (113) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plus(x1, z0)), PLUS(x1, head(cons(z0, z1)))) by SUMITER(cons(z1, x1), z0) -> c10(IFSUM(isempty(cons(z1, x1)), cons(z1, x1), z0, plusIter(z0, z1, 0)), PLUS(z0, head(cons(z1, x1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) ---------------------------------------- (114) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_2, c10_1, c2_2, c9_1 ---------------------------------------- (115) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) We considered the (Usable) Rules: tail(cons(z0, z1)) -> z1 tail(nil) -> nil And the Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(IFPLUS(x_1, x_2, x_3, x_4)) = x_2 POL(IFSUM(x_1, x_2, x_3, x_4)) = x_2 POL(LE(x_1, x_2)) = 0 POL(PLUS(x_1, x_2)) = 0 POL(PLUSITER(x_1, x_2, x_3)) = x_3 POL(SUMITER(x_1, x_2)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c10(x_1, x_2)) = x_1 + x_2 POL(c12(x_1)) = x_1 POL(c2(x_1)) = x_1 POL(c2(x_1, x_2)) = x_1 + x_2 POL(c4(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(cons(x_1, x_2)) = [1] + x_2 POL(error) = 0 POL(false) = 0 POL(head(x_1)) = 0 POL(ifPlus(x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4 POL(isempty(x_1)) = [1] + x_1 POL(le(x_1, x_2)) = x_1 POL(nil) = 0 POL(plus(x_1, x_2)) = [1] + x_1 + x_2 POL(plusIter(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3 POL(s(x_1)) = 0 POL(tail(x_1)) = x_1 POL(true) = [1] ---------------------------------------- (116) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_2, c10_1, c2_2, c9_1 ---------------------------------------- (117) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plus(x1, head(cons(z0, z1)))), PLUS(x1, head(cons(z0, z1)))) by SUMITER(cons(x0, x1), z0) -> c10(IFSUM(false, cons(x0, x1), z0, plusIter(z0, head(cons(x0, x1)), 0)), PLUS(z0, head(cons(x0, x1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) ---------------------------------------- (118) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_1, c2_2, c9_1, c10_2 ---------------------------------------- (119) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) by SUMITER(nil, x0) -> c10(PLUS(x0, error)) ---------------------------------------- (120) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_1, c2_2, c9_1, c10_2 ---------------------------------------- (121) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) by SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) ---------------------------------------- (122) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, IFPLUS_4, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2 Compound Symbols: c1_1, c4_1, c7_1, c12_1, c2_1, c10_1, c2_2, c9_1, c10_2 ---------------------------------------- (123) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace IFPLUS(false, z0, z1, z2) -> c4(PLUSITER(z0, s(z1), s(z2))) by IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) ---------------------------------------- (124) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(s(z0)), x1, s(0)) -> c2(IFPLUS(false, s(s(z0)), x1, s(0)), LE(s(s(z0)), s(0))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4 Compound Symbols: c1_1, c7_1, c12_1, c2_1, c10_1, c2_2, c9_1, c10_2, c4_1 ---------------------------------------- (125) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (126) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4 Compound Symbols: c1_1, c7_1, c12_1, c2_1, c10_1, c2_2, c9_1, c10_2, c4_1, c_1 ---------------------------------------- (127) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) by SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) ---------------------------------------- (128) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4 Compound Symbols: c1_1, c7_1, c12_1, c2_1, c10_1, c2_2, c9_1, c10_2, c4_1, c_1 ---------------------------------------- (129) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) by SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) ---------------------------------------- (130) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(nil, x1) -> c9(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4 Compound Symbols: c1_1, c7_1, c12_1, c2_1, c10_1, c2_2, c9_1, c10_2, c4_1, c_1 ---------------------------------------- (131) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0))) by SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) ---------------------------------------- (132) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4 Compound Symbols: c1_1, c7_1, c12_1, c2_1, c10_1, c2_2, c9_1, c10_2, c4_1, c_1 ---------------------------------------- (133) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(z1, x1), z0) -> c9(IFSUM(isempty(cons(z1, x1)), cons(z1, x1), z0, plusIter(z0, z1, 0))) by SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) ---------------------------------------- (134) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4 Compound Symbols: c1_1, c7_1, c12_1, c2_1, c10_1, c2_2, c9_1, c10_2, c4_1, c_1 ---------------------------------------- (135) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) by SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) ---------------------------------------- (136) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x1) -> c9(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4 Compound Symbols: c1_1, c7_1, c12_1, c2_1, c10_1, c2_2, c9_1, c10_2, c4_1, c_1 ---------------------------------------- (137) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(x0, x1), z0) -> c9(IFSUM(false, cons(x0, x1), z0, plusIter(z0, head(cons(x0, x1)), 0))) by SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) ---------------------------------------- (138) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) S tuples: PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: PLUS_2, LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4 Compound Symbols: c1_1, c7_1, c12_1, c2_1, c10_1, c2_2, c9_1, c10_2, c4_1, c_1 ---------------------------------------- (139) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace PLUS(z0, z1) -> c1(PLUSITER(z0, z1, 0)) by PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) ---------------------------------------- (140) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c2_2, c9_1, c10_2, c4_1, c_1, c1_1 ---------------------------------------- (141) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace PLUSITER(s(s(z0)), x1, s(s(z1))) -> c2(IFPLUS(le(z0, z1), s(s(z0)), x1, s(s(z1))), LE(s(s(z0)), s(s(z1)))) by PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0))), LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) ---------------------------------------- (142) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0))), LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0))), LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c_1, c1_1, c2_2 ---------------------------------------- (143) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (144) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c_1, c1_1, c2_2, c3_1 ---------------------------------------- (145) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(z0, z1), x2) -> c9(IFSUM(false, cons(z0, z1), x2, plus(x2, z0))) by SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) ---------------------------------------- (146) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c_1, c1_1, c2_2, c3_1 ---------------------------------------- (147) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace PLUSITER(s(x0), x1, s(x2)) -> c2(LE(s(x0), s(x2))) by PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) ---------------------------------------- (148) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c_1, c1_1, c2_2, c3_1 ---------------------------------------- (149) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) by SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) ---------------------------------------- (150) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c_1, c1_1, c2_2, c3_1 ---------------------------------------- (151) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace PLUSITER(s(0), x1, s(z0)) -> c2(LE(s(0), s(z0))) by PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) ---------------------------------------- (152) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c_1, c1_1, c2_2, c3_1 ---------------------------------------- (153) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) by SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) ---------------------------------------- (154) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c_1, c1_1, c2_2, c3_1 ---------------------------------------- (155) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace IFPLUS(false, s(s(x0)), x1, s(s(x2))) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(s(x2))))) by IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) ---------------------------------------- (156) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c_1, c1_1, c2_2, c3_1 ---------------------------------------- (157) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace PLUSITER(s(s(z0)), x1, s(0)) -> c(IFPLUS(false, s(s(z0)), x1, s(0))) by PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) ---------------------------------------- (158) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c_1, c1_1, c2_2, c3_1 ---------------------------------------- (159) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace IFPLUS(false, s(s(x0)), x1, s(0)) -> c4(PLUSITER(s(s(x0)), s(x1), s(s(0)))) by IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) ---------------------------------------- (160) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c_1, c1_1, c2_2, c3_1 ---------------------------------------- (161) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) by SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) ---------------------------------------- (162) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c_1, c1_1, c2_2, c3_1 ---------------------------------------- (163) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) by SUMITER(nil, z0) -> c10(PLUS(z0, error)) ---------------------------------------- (164) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c_1, c1_1, c2_2, c3_1 ---------------------------------------- (165) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace PLUSITER(s(s(z0)), x1, s(0)) -> c(LE(s(s(z0)), s(0))) by PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) ---------------------------------------- (166) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, x1) -> c10(IFSUM(isempty(nil), nil, x1, plusIter(x1, error, 0)), PLUS(x1, head(nil))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c1_1, c2_2, c3_1, c_1 ---------------------------------------- (167) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, head(nil))) by SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) ---------------------------------------- (168) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c10_1, c9_1, c10_2, c4_1, c1_1, c2_2, c3_1, c_1 ---------------------------------------- (169) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(nil, x0) -> c10(PLUS(x0, head(nil))) by SUMITER(nil, z0) -> c10(PLUS(z0, error)) ---------------------------------------- (170) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), x1, plusIter(x1, z0, 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c2_2, c3_1, c_1 ---------------------------------------- (171) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(z1, x1), z0) -> c10(IFSUM(isempty(cons(z1, x1)), cons(z1, x1), z0, plusIter(z0, z1, 0)), PLUS(z0, head(cons(z1, x1)))) by SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) ---------------------------------------- (172) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c2_2, c3_1, c_1 ---------------------------------------- (173) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) by SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) ---------------------------------------- (174) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c2_2, c3_1, c_1 ---------------------------------------- (175) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) by SUMITER(cons(z0, z1), z2) -> c10(PLUS(z2, z0)) ---------------------------------------- (176) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) SUMITER(cons(z0, z1), z2) -> c10(PLUS(z2, z0)) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c2_2, c3_1, c_1 ---------------------------------------- (177) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(IFPLUS(le(x0, s(x2)), s(s(x0)), s(x1), s(s(s(x2)))), LE(s(s(x0)), s(s(s(x2))))) by PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c2(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0)))), LE(s(s(x0)), s(s(s(0))))) ---------------------------------------- (178) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) SUMITER(cons(z0, z1), z2) -> c10(PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c2(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0)))), LE(s(s(x0)), s(s(s(0))))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c2(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0)))), LE(s(s(x0)), s(s(s(0))))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c3_1, c_1, c2_2 ---------------------------------------- (179) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (180) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) SUMITER(cons(z0, z1), z2) -> c10(PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c3_1, c_1, c2_2, c5_1 ---------------------------------------- (181) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(x1), s(s(0)))) by PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) ---------------------------------------- (182) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) SUMITER(cons(z0, z1), z2) -> c10(PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c3_1, c_1, c2_2, c5_1 ---------------------------------------- (183) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) by PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) ---------------------------------------- (184) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(cons(z0, z1), x1) -> c10(IFSUM(false, cons(z0, z1), x1, plusIter(x1, head(cons(z0, z1)), 0)), PLUS(x1, head(cons(z0, z1)))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) SUMITER(cons(z0, z1), z2) -> c10(PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c_1, c2_2, c5_1, c3_1 ---------------------------------------- (185) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(x0, x1), z0) -> c10(IFSUM(false, cons(x0, x1), z0, plusIter(z0, head(cons(x0, x1)), 0)), PLUS(z0, head(cons(x0, x1)))) by SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) ---------------------------------------- (186) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) SUMITER(cons(z0, z1), z2) -> c10(PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c_1, c2_2, c5_1, c3_1 ---------------------------------------- (187) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(z0, z1), x2) -> c10(IFSUM(false, cons(z0, z1), x2, plus(x2, z0)), PLUS(x2, head(cons(z0, z1)))) by SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) ---------------------------------------- (188) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) SUMITER(cons(z0, z1), z2) -> c10(PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c_1, c2_2, c5_1, c3_1 ---------------------------------------- (189) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) by SUMITER(nil, z0) -> c9(IFSUM(true, nil, z0, ifPlus(le(z0, 0), z0, error, 0))) ---------------------------------------- (190) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) SUMITER(cons(z0, z1), z2) -> c10(PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) SUMITER(nil, z0) -> c9(IFSUM(true, nil, z0, ifPlus(le(z0, 0), z0, error, 0))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) SUMITER(nil, z0) -> c9(IFSUM(true, nil, z0, ifPlus(le(z0, 0), z0, error, 0))) K tuples: SUMITER(nil, x1) -> c10(PLUS(x1, head(nil))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(cons(x0, x1), x2) -> c10(PLUS(x2, head(cons(x0, x1)))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c_1, c2_2, c5_1, c3_1 ---------------------------------------- (191) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: SUMITER(nil, z0) -> c9(IFSUM(true, nil, z0, ifPlus(le(z0, 0), z0, error, 0))) ---------------------------------------- (192) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) SUMITER(cons(z0, z1), z2) -> c10(PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) K tuples: SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c_1, c2_2, c5_1, c3_1 ---------------------------------------- (193) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) by SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) ---------------------------------------- (194) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) SUMITER(cons(z0, z1), z2) -> c10(PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) K tuples: SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c_1, c2_2, c5_1, c3_1 ---------------------------------------- (195) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) by SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) ---------------------------------------- (196) Obligation: Complexity Dependency Tuples Problem Rules: le(s(z0), 0) -> false le(0, z0) -> true le(s(z0), s(z1)) -> le(z0, z1) isempty(nil) -> true isempty(cons(z0, z1)) -> false plus(z0, z1) -> plusIter(z0, z1, 0) head(nil) -> error head(cons(z0, z1)) -> z0 plusIter(z0, z1, z2) -> ifPlus(le(z0, z2), z0, z1, z2) ifPlus(true, z0, z1, z2) -> z1 ifPlus(false, z0, z1, z2) -> plusIter(z0, s(z1), s(z2)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) SUMITER(nil, x0) -> c10(PLUS(x0, error)) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, head(cons(z0, z1)), 0))) SUMITER(nil, z0) -> c9(IFSUM(isempty(nil), nil, z0, ifPlus(le(z0, 0), z0, error, 0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) SUMITER(cons(z0, z1), z2) -> c10(PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) S tuples: LE(s(z0), s(z1)) -> c7(LE(z0, z1)) IFSUM(false, z0, z1, z2) -> c12(SUMITER(tail(z0), z2)) PLUSITER(s(z0), x1, 0) -> c2(IFPLUS(false, s(z0), x1, 0)) SUMITER(x0, z0) -> c9(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0))) SUMITER(x0, z0) -> c10(IFSUM(isempty(x0), x0, z0, ifPlus(le(z0, 0), z0, head(x0), 0)), PLUS(z0, head(x0))) IFPLUS(false, s(x0), x1, 0) -> c4(PLUSITER(s(x0), s(x1), s(0))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, plusIter(z2, z0, 0))) PLUS(s(y0), z1) -> c1(PLUSITER(s(y0), z1, 0)) PLUSITER(s(x0), s(x1), s(0)) -> c2(LE(s(x0), s(0))) PLUSITER(s(s(x0)), s(x1), s(s(0))) -> c2(LE(s(s(x0)), s(s(0)))) PLUSITER(s(s(x0)), s(x1), s(s(s(x2)))) -> c2(LE(s(s(x0)), s(s(s(x2))))) SUMITER(nil, z0) -> c10(IFSUM(isempty(nil), nil, z0, plusIter(z0, error, 0)), PLUS(z0, error)) PLUSITER(s(0), s(x1), s(0)) -> c2(LE(s(0), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(isempty(cons(z0, z1)), cons(z0, z1), z2, plusIter(z2, z0, 0)), PLUS(z2, z0)) IFPLUS(false, s(s(x0)), s(x1), s(s(s(x2)))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2)))))) IFPLUS(false, s(s(x0)), s(x1), s(s(0))) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(IFPLUS(false, s(s(z0)), s(x1), s(0))) IFPLUS(false, s(s(x0)), s(x1), s(0)) -> c4(PLUSITER(s(s(x0)), s(s(x1)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plusIter(z2, head(cons(z0, z1)), 0)), PLUS(z2, z0)) PLUSITER(s(s(z0)), s(x1), s(0)) -> c(LE(s(s(z0)), s(0))) SUMITER(cons(z0, z1), z2) -> c10(IFSUM(false, cons(z0, z1), z2, plus(z2, z0)), PLUS(z2, z0)) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(s(x2))))) -> c2(IFPLUS(le(x0, s(s(x2))), s(s(x0)), s(s(x1)), s(s(s(s(x2))))), LE(s(s(x0)), s(s(s(s(x2)))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(IFPLUS(le(x0, s(0)), s(s(x0)), s(s(x1)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(s(0)))) -> c5(LE(s(s(x0)), s(s(s(0))))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(IFPLUS(le(x0, 0), s(s(x0)), s(s(x1)), s(s(0)))) PLUSITER(s(s(x0)), s(s(x1)), s(s(0))) -> c3(LE(s(s(x0)), s(s(0)))) SUMITER(cons(z0, z1), z2) -> c9(IFSUM(false, cons(z0, z1), z2, ifPlus(le(z2, 0), z2, z0, 0))) K tuples: SUMITER(x0, x1) -> c10(PLUS(x1, head(x0))) Defined Rule Symbols: le_2, isempty_1, plus_2, head_1, plusIter_3, ifPlus_4, tail_1 Defined Pair Symbols: LE_2, IFSUM_4, PLUSITER_3, SUMITER_2, IFPLUS_4, PLUS_2 Compound Symbols: c7_1, c12_1, c2_1, c9_1, c10_2, c10_1, c4_1, c1_1, c_1, c2_2, c5_1, c3_1