KILLED proof of input_4Kha5pcsGG.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), 18 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), 126 ms] (22) CpxRNTS (23) IntTrsBoundProof [UPPER BOUND(ID), 57 ms] (24) CpxRNTS (25) ResultPropagationProof [UPPER BOUND(ID), 2 ms] (26) CpxRNTS (27) IntTrsBoundProof [UPPER BOUND(ID), 192 ms] (28) CpxRNTS (29) IntTrsBoundProof [UPPER BOUND(ID), 54 ms] (30) CpxRNTS (31) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (32) CpxRNTS (33) IntTrsBoundProof [UPPER BOUND(ID), 243 ms] (34) CpxRNTS (35) IntTrsBoundProof [UPPER BOUND(ID), 88 ms] (36) CpxRNTS (37) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (38) CpxRNTS (39) IntTrsBoundProof [UPPER BOUND(ID), 150 ms] (40) CpxRNTS (41) IntTrsBoundProof [UPPER BOUND(ID), 53 ms] (42) CpxRNTS (43) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (44) CpxRNTS (45) IntTrsBoundProof [UPPER BOUND(ID), 242 ms] (46) CpxRNTS (47) IntTrsBoundProof [UPPER BOUND(ID), 64 ms] (48) CpxRNTS (49) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (50) CpxRNTS (51) IntTrsBoundProof [UPPER BOUND(ID), 95 ms] (52) CpxRNTS (53) IntTrsBoundProof [UPPER BOUND(ID), 12 ms] (54) CpxRNTS (55) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (56) CpxRNTS (57) IntTrsBoundProof [UPPER BOUND(ID), 7999 ms] (58) CpxRNTS (59) IntTrsBoundProof [UPPER BOUND(ID), 2142 ms] (60) CpxRNTS (61) CompletionProof [UPPER BOUND(ID), 0 ms] (62) CpxTypedWeightedCompleteTrs (63) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms] (64) CpxRNTS (65) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms] (66) CdtProblem (67) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (68) CdtProblem (69) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (70) CdtProblem (71) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (72) CdtProblem (73) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (74) CdtProblem (75) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (76) CdtProblem (77) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (78) CdtProblem (79) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (80) CdtProblem (81) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (82) CdtProblem (83) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (84) CdtProblem (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (86) CdtProblem (87) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (88) CdtProblem (89) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (90) CdtProblem (91) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 40 ms] (92) CdtProblem (93) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (94) CdtProblem (95) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (96) CdtProblem (97) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (98) CdtProblem (99) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (100) CdtProblem (101) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 2277 ms] (102) CdtProblem (103) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (104) CdtProblem (105) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (106) CdtProblem (107) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (108) CdtProblem (109) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (110) CdtProblem (111) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (112) CdtProblem (113) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 28 ms] (114) CdtProblem (115) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (116) CdtProblem (117) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (118) CdtProblem (119) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (120) CdtProblem (121) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 23 ms] (122) CdtProblem (123) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (124) CdtProblem (125) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 4 ms] (126) CdtProblem (127) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (128) CdtProblem (129) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (130) CdtProblem (131) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (132) CdtProblem (133) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 49 ms] (134) CdtProblem (135) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 60 ms] (136) CdtProblem (137) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (138) CdtProblem (139) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 45 ms] (140) CdtProblem (141) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (142) CdtProblem (143) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (144) CdtProblem (145) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (146) CdtProblem (147) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (148) CdtProblem (149) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (150) CdtProblem (151) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (152) CdtProblem (153) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (154) CdtProblem (155) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (156) CdtProblem (157) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (158) CdtProblem (159) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (160) CdtProblem (161) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (162) CdtProblem (163) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (164) CdtProblem (165) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (166) CdtProblem (167) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (168) CdtProblem (169) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (170) CdtProblem (171) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (172) CdtProblem (173) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (174) CdtProblem (175) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (176) CdtProblem (177) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (178) CdtProblem (179) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (180) CdtProblem (181) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (182) CdtProblem (183) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (184) CdtProblem (185) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (186) CdtProblem (187) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (188) CdtProblem (189) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (190) CdtProblem (191) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (192) CdtProblem (193) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (194) CdtProblem (195) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (196) CdtProblem (197) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (198) CdtProblem (199) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (200) CdtProblem (201) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (202) CdtProblem (203) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (204) CdtProblem (205) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (206) CdtProblem (207) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (208) CdtProblem (209) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (210) CdtProblem (211) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (212) CdtProblem (213) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (214) CdtProblem (215) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (216) CdtProblem (217) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (218) CdtProblem (219) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (220) CdtProblem (221) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (222) CdtProblem (223) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (224) CdtProblem (225) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (226) CdtProblem (227) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (228) CdtProblem (229) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (230) CdtProblem (231) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (232) CdtProblem (233) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (234) CdtProblem (235) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 75 ms] (236) CdtProblem (237) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (238) 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: prod(xs) -> prodIter(xs, s(0)) prodIter(xs, x) -> ifProd(isempty(xs), xs, x) ifProd(true, xs, x) -> x ifProd(false, xs, x) -> prodIter(tail(xs), times(x, head(xs))) plus(0, y) -> y plus(s(x), y) -> s(plus(x, y)) times(x, y) -> timesIter(x, y, 0, 0) timesIter(x, y, z, u) -> ifTimes(ge(u, x), x, y, z, u) ifTimes(true, x, y, z, u) -> z ifTimes(false, x, y, z, u) -> timesIter(x, y, plus(y, z), s(u)) isempty(nil) -> true isempty(cons(x, xs)) -> false head(nil) -> error head(cons(x, xs)) -> x tail(nil) -> nil tail(cons(x, xs)) -> xs ge(x, 0) -> true ge(0, s(y)) -> false ge(s(x), s(y)) -> ge(x, y) 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: prod(xs) -> prodIter(xs, s(0')) prodIter(xs, x) -> ifProd(isempty(xs), xs, x) ifProd(true, xs, x) -> x ifProd(false, xs, x) -> prodIter(tail(xs), times(x, head(xs))) plus(0', y) -> y plus(s(x), y) -> s(plus(x, y)) times(x, y) -> timesIter(x, y, 0', 0') timesIter(x, y, z, u) -> ifTimes(ge(u, x), x, y, z, u) ifTimes(true, x, y, z, u) -> z ifTimes(false, x, y, z, u) -> timesIter(x, y, plus(y, z), s(u)) isempty(nil) -> true isempty(cons(x, xs)) -> false head(nil) -> error head(cons(x, xs)) -> x tail(nil) -> nil tail(cons(x, xs)) -> xs ge(x, 0') -> true ge(0', s(y)) -> false ge(s(x), s(y)) -> ge(x, y) 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: prod(xs) -> prodIter(xs, s(0)) prodIter(xs, x) -> ifProd(isempty(xs), xs, x) ifProd(true, xs, x) -> x ifProd(false, xs, x) -> prodIter(tail(xs), times(x, head(xs))) plus(0, y) -> y plus(s(x), y) -> s(plus(x, y)) times(x, y) -> timesIter(x, y, 0, 0) timesIter(x, y, z, u) -> ifTimes(ge(u, x), x, y, z, u) ifTimes(true, x, y, z, u) -> z ifTimes(false, x, y, z, u) -> timesIter(x, y, plus(y, z), s(u)) isempty(nil) -> true isempty(cons(x, xs)) -> false head(nil) -> error head(cons(x, xs)) -> x tail(nil) -> nil tail(cons(x, xs)) -> xs ge(x, 0) -> true ge(0, s(y)) -> false ge(s(x), s(y)) -> ge(x, y) 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: prod(xs) -> prodIter(xs, s(0)) [1] prodIter(xs, x) -> ifProd(isempty(xs), xs, x) [1] ifProd(true, xs, x) -> x [1] ifProd(false, xs, x) -> prodIter(tail(xs), times(x, head(xs))) [1] plus(0, y) -> y [1] plus(s(x), y) -> s(plus(x, y)) [1] times(x, y) -> timesIter(x, y, 0, 0) [1] timesIter(x, y, z, u) -> ifTimes(ge(u, x), x, y, z, u) [1] ifTimes(true, x, y, z, u) -> z [1] ifTimes(false, x, y, z, u) -> timesIter(x, y, plus(y, z), s(u)) [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] ge(x, 0) -> true [1] ge(0, s(y)) -> false [1] ge(s(x), s(y)) -> ge(x, y) [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: prod(xs) -> prodIter(xs, s(0)) [1] prodIter(xs, x) -> ifProd(isempty(xs), xs, x) [1] ifProd(true, xs, x) -> x [1] ifProd(false, xs, x) -> prodIter(tail(xs), times(x, head(xs))) [1] plus(0, y) -> y [1] plus(s(x), y) -> s(plus(x, y)) [1] times(x, y) -> timesIter(x, y, 0, 0) [1] timesIter(x, y, z, u) -> ifTimes(ge(u, x), x, y, z, u) [1] ifTimes(true, x, y, z, u) -> z [1] ifTimes(false, x, y, z, u) -> timesIter(x, y, plus(y, z), s(u)) [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] ge(x, 0) -> true [1] ge(0, s(y)) -> false [1] ge(s(x), s(y)) -> ge(x, y) [1] a -> b [1] a -> c [1] The TRS has the following type information: prod :: nil:cons -> 0:s:error prodIter :: nil:cons -> 0:s:error -> 0:s:error s :: 0:s:error -> 0:s:error 0 :: 0:s:error ifProd :: true:false -> nil:cons -> 0:s:error -> 0:s:error isempty :: nil:cons -> true:false true :: true:false false :: true:false tail :: nil:cons -> nil:cons times :: 0:s:error -> 0:s:error -> 0:s:error head :: nil:cons -> 0:s:error plus :: 0:s:error -> 0:s:error -> 0:s:error timesIter :: 0:s:error -> 0:s:error -> 0:s:error -> 0:s:error -> 0:s:error ifTimes :: true:false -> 0:s:error -> 0:s:error -> 0:s:error -> 0:s:error -> 0:s:error ge :: 0:s:error -> 0:s:error -> true:false 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: prod_1 prodIter_2 ifProd_3 a (c) The following functions are completely defined: tail_1 times_2 head_1 isempty_1 plus_2 ge_2 timesIter_4 ifTimes_5 Due to the following rules being added: plus(v0, v1) -> null_plus [0] ge(v0, v1) -> null_ge [0] ifTimes(v0, v1, v2, v3, v4) -> null_ifTimes [0] And the following fresh constants: null_plus, null_ge, null_ifTimes ---------------------------------------- (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: prod(xs) -> prodIter(xs, s(0)) [1] prodIter(xs, x) -> ifProd(isempty(xs), xs, x) [1] ifProd(true, xs, x) -> x [1] ifProd(false, xs, x) -> prodIter(tail(xs), times(x, head(xs))) [1] plus(0, y) -> y [1] plus(s(x), y) -> s(plus(x, y)) [1] times(x, y) -> timesIter(x, y, 0, 0) [1] timesIter(x, y, z, u) -> ifTimes(ge(u, x), x, y, z, u) [1] ifTimes(true, x, y, z, u) -> z [1] ifTimes(false, x, y, z, u) -> timesIter(x, y, plus(y, z), s(u)) [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] ge(x, 0) -> true [1] ge(0, s(y)) -> false [1] ge(s(x), s(y)) -> ge(x, y) [1] a -> b [1] a -> c [1] plus(v0, v1) -> null_plus [0] ge(v0, v1) -> null_ge [0] ifTimes(v0, v1, v2, v3, v4) -> null_ifTimes [0] The TRS has the following type information: prod :: nil:cons -> 0:s:error:null_plus:null_ifTimes prodIter :: nil:cons -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes s :: 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes 0 :: 0:s:error:null_plus:null_ifTimes ifProd :: true:false:null_ge -> nil:cons -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes isempty :: nil:cons -> true:false:null_ge true :: true:false:null_ge false :: true:false:null_ge tail :: nil:cons -> nil:cons times :: 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes head :: nil:cons -> 0:s:error:null_plus:null_ifTimes plus :: 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes timesIter :: 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes ifTimes :: true:false:null_ge -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes ge :: 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> true:false:null_ge nil :: nil:cons cons :: 0:s:error:null_plus:null_ifTimes -> nil:cons -> nil:cons error :: 0:s:error:null_plus:null_ifTimes a :: b:c b :: b:c c :: b:c null_plus :: 0:s:error:null_plus:null_ifTimes null_ge :: true:false:null_ge null_ifTimes :: 0:s:error:null_plus:null_ifTimes 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: prod(xs) -> prodIter(xs, s(0)) [1] prodIter(nil, x) -> ifProd(true, nil, x) [2] prodIter(cons(x', xs'), x) -> ifProd(false, cons(x', xs'), x) [2] ifProd(true, xs, x) -> x [1] ifProd(false, nil, x) -> prodIter(nil, times(x, error)) [3] ifProd(false, cons(x'', xs''), x) -> prodIter(xs'', times(x, x'')) [3] plus(0, y) -> y [1] plus(s(x), y) -> s(plus(x, y)) [1] times(x, y) -> timesIter(x, y, 0, 0) [1] timesIter(0, y, z, u) -> ifTimes(true, 0, y, z, u) [2] timesIter(s(y'), y, z, 0) -> ifTimes(false, s(y'), y, z, 0) [2] timesIter(s(y''), y, z, s(x1)) -> ifTimes(ge(x1, y''), s(y''), y, z, s(x1)) [2] timesIter(x, y, z, u) -> ifTimes(null_ge, x, y, z, u) [1] ifTimes(true, x, y, z, u) -> z [1] ifTimes(false, x, 0, z, u) -> timesIter(x, 0, z, s(u)) [2] ifTimes(false, x, s(x2), z, u) -> timesIter(x, s(x2), s(plus(x2, z)), s(u)) [2] ifTimes(false, x, y, z, u) -> timesIter(x, y, null_plus, s(u)) [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] ge(x, 0) -> true [1] ge(0, s(y)) -> false [1] ge(s(x), s(y)) -> ge(x, y) [1] a -> b [1] a -> c [1] plus(v0, v1) -> null_plus [0] ge(v0, v1) -> null_ge [0] ifTimes(v0, v1, v2, v3, v4) -> null_ifTimes [0] The TRS has the following type information: prod :: nil:cons -> 0:s:error:null_plus:null_ifTimes prodIter :: nil:cons -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes s :: 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes 0 :: 0:s:error:null_plus:null_ifTimes ifProd :: true:false:null_ge -> nil:cons -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes isempty :: nil:cons -> true:false:null_ge true :: true:false:null_ge false :: true:false:null_ge tail :: nil:cons -> nil:cons times :: 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes head :: nil:cons -> 0:s:error:null_plus:null_ifTimes plus :: 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes timesIter :: 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes ifTimes :: true:false:null_ge -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes ge :: 0:s:error:null_plus:null_ifTimes -> 0:s:error:null_plus:null_ifTimes -> true:false:null_ge nil :: nil:cons cons :: 0:s:error:null_plus:null_ifTimes -> nil:cons -> nil:cons error :: 0:s:error:null_plus:null_ifTimes a :: b:c b :: b:c c :: b:c null_plus :: 0:s:error:null_plus:null_ifTimes null_ge :: true:false:null_ge null_ifTimes :: 0:s:error:null_plus:null_ifTimes 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_plus => 0 null_ge => 0 null_ifTimes => 0 ---------------------------------------- (14) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 1 }-> ge(x, y) :|: z' = 1 + x, x >= 0, y >= 0, z'' = 1 + y ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' = x, x >= 0 ge(z', z'') -{ 1 }-> 1 :|: y >= 0, z'' = 1 + y, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> x :|: xs >= 0, z' = 2, x >= 0, z'' = xs, z1 = x ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(x, x'')) :|: xs'' >= 0, x >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'', z1 = x ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(x, 1)) :|: z'' = 0, x >= 0, z' = 1, z1 = x ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z :|: z1 = y, z >= 0, z' = 2, z2 = z, x >= 0, y >= 0, z'' = x, z3 = u, u >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(x, y, 0, 1 + u) :|: z1 = y, z >= 0, z2 = z, x >= 0, y >= 0, z'' = x, z' = 1, z3 = u, u >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(x, 0, z, 1 + u) :|: z1 = 0, z >= 0, z2 = z, x >= 0, z'' = x, z' = 1, z3 = u, u >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(x, 1 + x2, 1 + plus(x2, z), 1 + u) :|: z >= 0, z2 = z, x >= 0, z'' = x, z' = 1, z3 = u, x2 >= 0, z1 = 1 + x2, u >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z2 = v3, v0 >= 0, v4 >= 0, z1 = v2, v1 >= 0, z'' = v1, z3 = v4, v2 >= 0, v3 >= 0, z' = v0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> y :|: z'' = y, y >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0 plus(z', z'') -{ 1 }-> 1 + plus(x, y) :|: z' = 1 + x, z'' = y, x >= 0, y >= 0 prod(z') -{ 1 }-> prodIter(xs, 1 + 0) :|: xs >= 0, z' = xs prodIter(z', z'') -{ 2 }-> ifProd(2, 0, x) :|: x >= 0, z'' = x, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', x) :|: x' >= 0, xs' >= 0, x >= 0, z' = 1 + x' + xs', z'' = x tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(x, y, 0, 0) :|: z' = x, z'' = y, x >= 0, y >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(ge(x1, y''), 1 + y'', y, z, 1 + x1) :|: z' = 1 + y'', z1 = z, z >= 0, x1 >= 0, z'' = y, y >= 0, z2 = 1 + x1, y'' >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, y, z, u) :|: z1 = z, z2 = u, z >= 0, z'' = y, y >= 0, z' = 0, u >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + y', y, z, 0) :|: z1 = z, z >= 0, z'' = y, z2 = 0, y >= 0, y' >= 0, z' = 1 + y' timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, x, y, z, u) :|: z1 = z, z2 = u, z >= 0, z' = x, z'' = y, x >= 0, y >= 0, u >= 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 :|: ge(z', z'') -{ 1 }-> ge(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(ge(z2 - 1, z' - 1), 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 ---------------------------------------- (17) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID)) Found the following analysis order by SCC decomposition: { tail } { isempty } { ge } { head } { plus } { a } { timesIter, ifTimes } { times } { prodIter, ifProd } { prod } ---------------------------------------- (18) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 1 }-> ge(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(ge(z2 - 1, z' - 1), 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {tail}, {isempty}, {ge}, {head}, {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} ---------------------------------------- (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 :|: ge(z', z'') -{ 1 }-> ge(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(ge(z2 - 1, z' - 1), 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {tail}, {isempty}, {ge}, {head}, {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} ---------------------------------------- (21) 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' ---------------------------------------- (22) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 1 }-> ge(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(ge(z2 - 1, z' - 1), 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {tail}, {isempty}, {ge}, {head}, {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: ?, size: O(n^1) [z'] ---------------------------------------- (23) 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 ---------------------------------------- (24) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 1 }-> ge(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(ge(z2 - 1, z' - 1), 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {isempty}, {ge}, {head}, {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] ---------------------------------------- (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 :|: ge(z', z'') -{ 1 }-> ge(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(ge(z2 - 1, z' - 1), 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {isempty}, {ge}, {head}, {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] ---------------------------------------- (27) 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 ---------------------------------------- (28) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 1 }-> ge(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(ge(z2 - 1, z' - 1), 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {isempty}, {ge}, {head}, {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: ?, size: O(1) [2] ---------------------------------------- (29) 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 ---------------------------------------- (30) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 1 }-> ge(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(ge(z2 - 1, z' - 1), 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {ge}, {head}, {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ---------------------------------------- (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 :|: ge(z', z'') -{ 1 }-> ge(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(ge(z2 - 1, z' - 1), 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {ge}, {head}, {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ---------------------------------------- (33) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: ge 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 :|: ge(z', z'') -{ 1 }-> ge(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(ge(z2 - 1, z' - 1), 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {ge}, {head}, {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: ?, size: O(1) [2] ---------------------------------------- (35) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using KoAT for: ge after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 2 + z' ---------------------------------------- (36) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 1 }-> ge(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(ge(z2 - 1, z' - 1), 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {head}, {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], 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 :|: ge(z', z'') -{ 2 + z' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 3 + z2 }-> ifTimes(s, 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: s >= 0, s <= 2, z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {head}, {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], 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 :|: ge(z', z'') -{ 2 + z' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 3 + z2 }-> ifTimes(s, 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: s >= 0, s <= 2, z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {head}, {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], 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 :|: ge(z', z'') -{ 2 + z' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 3 + z2 }-> ifTimes(s, 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: s >= 0, s <= 2, z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], 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 :|: ge(z', z'') -{ 2 + z' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 3 + z2 }-> ifTimes(s, 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: s >= 0, s <= 2, z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], 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: plus after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z' + z'' ---------------------------------------- (46) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 2 + z' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 3 + z2 }-> ifTimes(s, 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: s >= 0, s <= 2, z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {plus}, {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] plus: runtime: ?, size: O(n^1) [z' + z''] ---------------------------------------- (47) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: plus after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z' ---------------------------------------- (48) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 2 + z' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 1 + (z1 - 1), 1 + plus(z1 - 1, z2), 1 + z3) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 }-> 1 + plus(z' - 1, z'') :|: z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 3 + z2 }-> ifTimes(s, 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: s >= 0, s <= 2, z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] plus: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z''] ---------------------------------------- (49) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (50) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 2 + z' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 + z1 }-> timesIter(z'', 1 + (z1 - 1), 1 + s1, 1 + z3) :|: s1 >= 0, s1 <= z1 - 1 + z2, z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 + z' }-> 1 + s'' :|: s'' >= 0, s'' <= z' - 1 + z'', z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 3 + z2 }-> ifTimes(s, 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: s >= 0, s <= 2, z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] plus: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z''] ---------------------------------------- (51) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: a after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (52) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 2 + z' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 + z1 }-> timesIter(z'', 1 + (z1 - 1), 1 + s1, 1 + z3) :|: s1 >= 0, s1 <= z1 - 1 + z2, z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 + z' }-> 1 + s'' :|: s'' >= 0, s'' <= z' - 1 + z'', z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 3 + z2 }-> ifTimes(s, 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: s >= 0, s <= 2, z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {a}, {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] plus: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z''] a: runtime: ?, size: O(1) [1] ---------------------------------------- (53) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: a after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (54) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 2 + z' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 + z1 }-> timesIter(z'', 1 + (z1 - 1), 1 + s1, 1 + z3) :|: s1 >= 0, s1 <= z1 - 1 + z2, z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 + z' }-> 1 + s'' :|: s'' >= 0, s'' <= z' - 1 + z'', z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 3 + z2 }-> ifTimes(s, 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: s >= 0, s <= 2, z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] plus: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z''] a: runtime: O(1) [1], size: O(1) [1] ---------------------------------------- (55) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (56) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 2 + z' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 + z1 }-> timesIter(z'', 1 + (z1 - 1), 1 + s1, 1 + z3) :|: s1 >= 0, s1 <= z1 - 1 + z2, z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 + z' }-> 1 + s'' :|: s'' >= 0, s'' <= z' - 1 + z'', z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 3 + z2 }-> ifTimes(s, 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: s >= 0, s <= 2, z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] plus: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z''] a: runtime: O(1) [1], size: O(1) [1] ---------------------------------------- (57) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: timesIter after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? Computed SIZE bound using CoFloCo for: ifTimes after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (58) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 2 + z' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 + z1 }-> timesIter(z'', 1 + (z1 - 1), 1 + s1, 1 + z3) :|: s1 >= 0, s1 <= z1 - 1 + z2, z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 + z' }-> 1 + s'' :|: s'' >= 0, s'' <= z' - 1 + z'', z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 3 + z2 }-> ifTimes(s, 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: s >= 0, s <= 2, z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] plus: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z''] a: runtime: O(1) [1], size: O(1) [1] timesIter: runtime: ?, size: INF ifTimes: runtime: ?, size: INF ---------------------------------------- (59) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: timesIter after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (60) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 2 + z' }-> s' :|: s' >= 0, s' <= 2, z' - 1 >= 0, z'' - 1 >= 0 ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' >= 0 ge(z', z'') -{ 1 }-> 1 :|: z'' - 1 >= 0, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0 ifProd(z', z'', z1) -{ 3 }-> prodIter(xs'', times(z1, x'')) :|: xs'' >= 0, z1 >= 0, z' = 1, x'' >= 0, z'' = 1 + x'' + xs'' ifProd(z', z'', z1) -{ 3 }-> prodIter(0, times(z1, 1)) :|: z'' = 0, z1 >= 0, z' = 1 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(z'', z1, 0, 1 + z3) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 }-> timesIter(z'', 0, z2, 1 + z3) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 2 + z1 }-> timesIter(z'', 1 + (z1 - 1), 1 + s1, 1 + z3) :|: s1 >= 0, s1 <= z1 - 1 + z2, z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0, z3 >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z' >= 0, z3 >= 0, z'' >= 0, z1 >= 0, z2 >= 0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0 plus(z', z'') -{ 1 + z' }-> 1 + s'' :|: s'' >= 0, s'' <= z' - 1 + z'', z' - 1 >= 0, z'' >= 0 prod(z') -{ 1 }-> prodIter(z', 1 + 0) :|: z' >= 0 prodIter(z', z'') -{ 2 }-> ifProd(2, 0, z'') :|: z'' >= 0, z' = 0 prodIter(z', z'') -{ 2 }-> ifProd(1, 1 + x' + xs', z'') :|: x' >= 0, xs' >= 0, z'' >= 0, z' = 1 + x' + xs' tail(z') -{ 1 }-> xs :|: xs >= 0, z' = 1 + x + xs, x >= 0 tail(z') -{ 1 }-> 0 :|: z' = 0 times(z', z'') -{ 1 }-> timesIter(z', z'', 0, 0) :|: z' >= 0, z'' >= 0 timesIter(z', z'', z1, z2) -{ 3 + z2 }-> ifTimes(s, 1 + (z' - 1), z'', z1, 1 + (z2 - 1)) :|: s >= 0, s <= 2, z1 >= 0, z2 - 1 >= 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(2, 0, z'', z1, z2) :|: z1 >= 0, z'' >= 0, z' = 0, z2 >= 0 timesIter(z', z'', z1, z2) -{ 2 }-> ifTimes(1, 1 + (z' - 1), z'', z1, 0) :|: z1 >= 0, z2 = 0, z'' >= 0, z' - 1 >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(0, z', z'', z1, z2) :|: z1 >= 0, z' >= 0, z'' >= 0, z2 >= 0 Function symbols to be analyzed: {timesIter,ifTimes}, {times}, {prodIter,ifProd}, {prod} Previous analysis results are: tail: runtime: O(1) [1], size: O(n^1) [z'] isempty: runtime: O(1) [1], size: O(1) [2] ge: runtime: O(n^1) [2 + z'], size: O(1) [2] head: runtime: O(1) [1], size: O(n^1) [1 + z'] plus: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z''] a: runtime: O(1) [1], size: O(1) [1] timesIter: runtime: INF, size: INF ifTimes: runtime: ?, size: INF ---------------------------------------- (61) CompletionProof (UPPER BOUND(ID)) The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added: plus(v0, v1) -> null_plus [0] ge(v0, v1) -> null_ge [0] ifProd(v0, v1, v2) -> null_ifProd [0] ifTimes(v0, v1, v2, v3, v4) -> null_ifTimes [0] And the following fresh constants: null_plus, null_ge, null_ifProd, null_ifTimes ---------------------------------------- (62) Obligation: Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: prod(xs) -> prodIter(xs, s(0)) [1] prodIter(xs, x) -> ifProd(isempty(xs), xs, x) [1] ifProd(true, xs, x) -> x [1] ifProd(false, xs, x) -> prodIter(tail(xs), times(x, head(xs))) [1] plus(0, y) -> y [1] plus(s(x), y) -> s(plus(x, y)) [1] times(x, y) -> timesIter(x, y, 0, 0) [1] timesIter(x, y, z, u) -> ifTimes(ge(u, x), x, y, z, u) [1] ifTimes(true, x, y, z, u) -> z [1] ifTimes(false, x, y, z, u) -> timesIter(x, y, plus(y, z), s(u)) [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] ge(x, 0) -> true [1] ge(0, s(y)) -> false [1] ge(s(x), s(y)) -> ge(x, y) [1] a -> b [1] a -> c [1] plus(v0, v1) -> null_plus [0] ge(v0, v1) -> null_ge [0] ifProd(v0, v1, v2) -> null_ifProd [0] ifTimes(v0, v1, v2, v3, v4) -> null_ifTimes [0] The TRS has the following type information: prod :: nil:cons -> 0:s:error:null_plus:null_ifProd:null_ifTimes prodIter :: nil:cons -> 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes s :: 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes 0 :: 0:s:error:null_plus:null_ifProd:null_ifTimes ifProd :: true:false:null_ge -> nil:cons -> 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes isempty :: nil:cons -> true:false:null_ge true :: true:false:null_ge false :: true:false:null_ge tail :: nil:cons -> nil:cons times :: 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes head :: nil:cons -> 0:s:error:null_plus:null_ifProd:null_ifTimes plus :: 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes timesIter :: 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes ifTimes :: true:false:null_ge -> 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes ge :: 0:s:error:null_plus:null_ifProd:null_ifTimes -> 0:s:error:null_plus:null_ifProd:null_ifTimes -> true:false:null_ge nil :: nil:cons cons :: 0:s:error:null_plus:null_ifProd:null_ifTimes -> nil:cons -> nil:cons error :: 0:s:error:null_plus:null_ifProd:null_ifTimes a :: b:c b :: b:c c :: b:c null_plus :: 0:s:error:null_plus:null_ifProd:null_ifTimes null_ge :: true:false:null_ge null_ifProd :: 0:s:error:null_plus:null_ifProd:null_ifTimes null_ifTimes :: 0:s:error:null_plus:null_ifProd:null_ifTimes Rewrite Strategy: INNERMOST ---------------------------------------- (63) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID)) Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction. The constant constructors are abstracted as follows: 0 => 0 true => 2 false => 1 nil => 0 error => 1 b => 0 c => 1 null_plus => 0 null_ge => 0 null_ifProd => 0 null_ifTimes => 0 ---------------------------------------- (64) Obligation: Complexity RNTS consisting of the following rules: a -{ 1 }-> 1 :|: a -{ 1 }-> 0 :|: ge(z', z'') -{ 1 }-> ge(x, y) :|: z' = 1 + x, x >= 0, y >= 0, z'' = 1 + y ge(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' = x, x >= 0 ge(z', z'') -{ 1 }-> 1 :|: y >= 0, z'' = 1 + y, z' = 0 ge(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0 head(z') -{ 1 }-> x :|: xs >= 0, z' = 1 + x + xs, x >= 0 head(z') -{ 1 }-> 1 :|: z' = 0 ifProd(z', z'', z1) -{ 1 }-> x :|: xs >= 0, z' = 2, x >= 0, z'' = xs, z1 = x ifProd(z', z'', z1) -{ 1 }-> prodIter(tail(xs), times(x, head(xs))) :|: xs >= 0, x >= 0, z'' = xs, z' = 1, z1 = x ifProd(z', z'', z1) -{ 0 }-> 0 :|: v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, z' = v0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> z :|: z1 = y, z >= 0, z' = 2, z2 = z, x >= 0, y >= 0, z'' = x, z3 = u, u >= 0 ifTimes(z', z'', z1, z2, z3) -{ 1 }-> timesIter(x, y, plus(y, z), 1 + u) :|: z1 = y, z >= 0, z2 = z, x >= 0, y >= 0, z'' = x, z' = 1, z3 = u, u >= 0 ifTimes(z', z'', z1, z2, z3) -{ 0 }-> 0 :|: z2 = v3, v0 >= 0, v4 >= 0, z1 = v2, v1 >= 0, z'' = v1, z3 = v4, v2 >= 0, v3 >= 0, z' = v0 isempty(z') -{ 1 }-> 2 :|: z' = 0 isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0 plus(z', z'') -{ 1 }-> y :|: z'' = y, y >= 0, z' = 0 plus(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0 plus(z', z'') -{ 1 }-> 1 + plus(x, y) :|: z' = 1 + x, z'' = y, x >= 0, y >= 0 prod(z') -{ 1 }-> prodIter(xs, 1 + 0) :|: xs >= 0, z' = xs prodIter(z', z'') -{ 1 }-> ifProd(isempty(xs), xs, x) :|: 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 times(z', z'') -{ 1 }-> timesIter(x, y, 0, 0) :|: z' = x, z'' = y, x >= 0, y >= 0 timesIter(z', z'', z1, z2) -{ 1 }-> ifTimes(ge(u, x), x, y, z, u) :|: z1 = z, z2 = u, z >= 0, z' = x, z'' = y, x >= 0, y >= 0, u >= 0 Only complete derivations are relevant for the runtime complexity. ---------------------------------------- (65) CpxTrsToCdtProof (UPPER BOUND(ID)) Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT ---------------------------------------- (66) Obligation: Complexity Dependency Tuples Problem Rules: prod(z0) -> prodIter(z0, s(0)) prodIter(z0, z1) -> ifProd(isempty(z0), z0, z1) ifProd(true, z0, z1) -> z1 ifProd(false, z0, z1) -> prodIter(tail(z0), times(z1, head(z0))) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) times(z0, z1) -> timesIter(z0, z1, 0, 0) timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) isempty(nil) -> true isempty(cons(z0, z1)) -> false head(nil) -> error head(cons(z0, z1)) -> z0 tail(nil) -> nil tail(cons(z0, z1)) -> z1 ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) a -> b a -> c Tuples: PROD(z0) -> c1(PRODITER(z0, s(0))) PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1), ISEMPTY(z0)) IFPROD(true, z0, z1) -> c3 IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0))), TAIL(z0)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0)), HEAD(z0)) PLUS(0, z0) -> c6 PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) IFTIMES(true, z0, z1, z2, z3) -> c10 IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) ISEMPTY(nil) -> c12 ISEMPTY(cons(z0, z1)) -> c13 HEAD(nil) -> c14 HEAD(cons(z0, z1)) -> c15 TAIL(nil) -> c16 TAIL(cons(z0, z1)) -> c17 GE(z0, 0) -> c18 GE(0, s(z0)) -> c19 GE(s(z0), s(z1)) -> c20(GE(z0, z1)) A -> c21 A -> c22 S tuples: PROD(z0) -> c1(PRODITER(z0, s(0))) PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1), ISEMPTY(z0)) IFPROD(true, z0, z1) -> c3 IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0))), TAIL(z0)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0)), HEAD(z0)) PLUS(0, z0) -> c6 PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) IFTIMES(true, z0, z1, z2, z3) -> c10 IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) ISEMPTY(nil) -> c12 ISEMPTY(cons(z0, z1)) -> c13 HEAD(nil) -> c14 HEAD(cons(z0, z1)) -> c15 TAIL(nil) -> c16 TAIL(cons(z0, z1)) -> c17 GE(z0, 0) -> c18 GE(0, s(z0)) -> c19 GE(s(z0), s(z1)) -> c20(GE(z0, z1)) A -> c21 A -> c22 K tuples:none Defined Rule Symbols: prod_1, prodIter_2, ifProd_3, plus_2, times_2, timesIter_4, ifTimes_5, isempty_1, head_1, tail_1, ge_2, a Defined Pair Symbols: PROD_1, PRODITER_2, IFPROD_3, PLUS_2, TIMES_2, TIMESITER_4, IFTIMES_5, ISEMPTY_1, HEAD_1, TAIL_1, GE_2, A Compound Symbols: c1_1, c2_2, c3, c4_2, c5_3, c6, c7_1, c8_1, c9_2, c10, c11_2, c12, c13, c14, c15, c16, c17, c18, c19, c20_1, c21, c22 ---------------------------------------- (67) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: PROD(z0) -> c1(PRODITER(z0, s(0))) Removed 13 trailing nodes: TAIL(nil) -> c16 TAIL(cons(z0, z1)) -> c17 ISEMPTY(nil) -> c12 A -> c22 GE(z0, 0) -> c18 PLUS(0, z0) -> c6 ISEMPTY(cons(z0, z1)) -> c13 A -> c21 IFPROD(true, z0, z1) -> c3 HEAD(cons(z0, z1)) -> c15 GE(0, s(z0)) -> c19 HEAD(nil) -> c14 IFTIMES(true, z0, z1, z2, z3) -> c10 ---------------------------------------- (68) Obligation: Complexity Dependency Tuples Problem Rules: prod(z0) -> prodIter(z0, s(0)) prodIter(z0, z1) -> ifProd(isempty(z0), z0, z1) ifProd(true, z0, z1) -> z1 ifProd(false, z0, z1) -> prodIter(tail(z0), times(z1, head(z0))) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) times(z0, z1) -> timesIter(z0, z1, 0, 0) timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) isempty(nil) -> true isempty(cons(z0, z1)) -> false head(nil) -> error head(cons(z0, z1)) -> z0 tail(nil) -> nil tail(cons(z0, z1)) -> z1 ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) a -> b a -> c Tuples: PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1), ISEMPTY(z0)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0))), TAIL(z0)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0)), HEAD(z0)) PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) S tuples: PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1), ISEMPTY(z0)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0))), TAIL(z0)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0)), HEAD(z0)) PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) K tuples:none Defined Rule Symbols: prod_1, prodIter_2, ifProd_3, plus_2, times_2, timesIter_4, ifTimes_5, isempty_1, head_1, tail_1, ge_2, a Defined Pair Symbols: PRODITER_2, IFPROD_3, PLUS_2, TIMES_2, TIMESITER_4, IFTIMES_5, GE_2 Compound Symbols: c2_2, c4_2, c5_3, c7_1, c8_1, c9_2, c11_2, c20_1 ---------------------------------------- (69) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 3 trailing tuple parts ---------------------------------------- (70) Obligation: Complexity Dependency Tuples Problem Rules: prod(z0) -> prodIter(z0, s(0)) prodIter(z0, z1) -> ifProd(isempty(z0), z0, z1) ifProd(true, z0, z1) -> z1 ifProd(false, z0, z1) -> prodIter(tail(z0), times(z1, head(z0))) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) times(z0, z1) -> timesIter(z0, z1, 0, 0) timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) isempty(nil) -> true isempty(cons(z0, z1)) -> false head(nil) -> error head(cons(z0, z1)) -> z0 tail(nil) -> nil tail(cons(z0, z1)) -> z1 ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) a -> b a -> c Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) K tuples:none Defined Rule Symbols: prod_1, prodIter_2, ifProd_3, plus_2, times_2, timesIter_4, ifTimes_5, isempty_1, head_1, tail_1, ge_2, a Defined Pair Symbols: PLUS_2, TIMES_2, TIMESITER_4, IFTIMES_5, GE_2, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c9_2, c11_2, c20_1, c2_1, c4_1, c5_2 ---------------------------------------- (71) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: prod(z0) -> prodIter(z0, s(0)) prodIter(z0, z1) -> ifProd(isempty(z0), z0, z1) ifProd(true, z0, z1) -> z1 ifProd(false, z0, z1) -> prodIter(tail(z0), times(z1, head(z0))) a -> b a -> c ---------------------------------------- (72) Obligation: Complexity Dependency Tuples Problem Rules: ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) isempty(nil) -> true isempty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) K tuples:none Defined Rule Symbols: ge_2, plus_2, isempty_1, tail_1, times_2, head_1, timesIter_4, ifTimes_5 Defined Pair Symbols: PLUS_2, TIMES_2, TIMESITER_4, IFTIMES_5, GE_2, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c9_2, c11_2, c20_1, c2_1, c4_1, c5_2 ---------------------------------------- (73) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) by TIMESITER(0, x1, x2, z0) -> c9(IFTIMES(true, 0, x1, x2, z0), GE(z0, 0)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0), GE(0, s(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) ---------------------------------------- (74) Obligation: Complexity Dependency Tuples Problem Rules: ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) isempty(nil) -> true isempty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(0, x1, x2, z0) -> c9(IFTIMES(true, 0, x1, x2, z0), GE(z0, 0)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0), GE(0, s(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(0, x1, x2, z0) -> c9(IFTIMES(true, 0, x1, x2, z0), GE(z0, 0)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0), GE(0, s(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) K tuples:none Defined Rule Symbols: ge_2, plus_2, isempty_1, tail_1, times_2, head_1, timesIter_4, ifTimes_5 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c2_1, c4_1, c5_2, c9_2 ---------------------------------------- (75) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: TIMESITER(0, x1, x2, z0) -> c9(IFTIMES(true, 0, x1, x2, z0), GE(z0, 0)) ---------------------------------------- (76) Obligation: Complexity Dependency Tuples Problem Rules: ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) isempty(nil) -> true isempty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0), GE(0, s(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0), GE(0, s(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) K tuples:none Defined Rule Symbols: ge_2, plus_2, isempty_1, tail_1, times_2, head_1, timesIter_4, ifTimes_5 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c2_1, c4_1, c5_2, c9_2 ---------------------------------------- (77) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (78) Obligation: Complexity Dependency Tuples Problem Rules: ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) isempty(nil) -> true isempty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) K tuples:none Defined Rule Symbols: ge_2, plus_2, isempty_1, tail_1, times_2, head_1, timesIter_4, ifTimes_5 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c2_1, c4_1, c5_2, c9_2, c9_1 ---------------------------------------- (79) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) by PRODITER(nil, x1) -> c2(IFPROD(true, nil, x1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) ---------------------------------------- (80) Obligation: Complexity Dependency Tuples Problem Rules: ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) isempty(nil) -> true isempty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(nil, x1) -> c2(IFPROD(true, nil, x1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(nil, x1) -> c2(IFPROD(true, nil, x1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) K tuples:none Defined Rule Symbols: ge_2, plus_2, isempty_1, tail_1, times_2, head_1, timesIter_4, ifTimes_5 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, IFPROD_3, TIMESITER_4, PRODITER_2 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c4_1, c5_2, c9_2, c9_1, c2_1 ---------------------------------------- (81) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: PRODITER(nil, x1) -> c2(IFPROD(true, nil, x1)) ---------------------------------------- (82) Obligation: Complexity Dependency Tuples Problem Rules: ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) isempty(nil) -> true isempty(cons(z0, z1)) -> false tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) K tuples:none Defined Rule Symbols: ge_2, plus_2, isempty_1, tail_1, times_2, head_1, timesIter_4, ifTimes_5 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, IFPROD_3, TIMESITER_4, PRODITER_2 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c4_1, c5_2, c9_2, c9_1, c2_1 ---------------------------------------- (83) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: isempty(nil) -> true isempty(cons(z0, z1)) -> false ---------------------------------------- (84) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) K tuples:none Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, IFPROD_3, TIMESITER_4, PRODITER_2 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c4_1, c5_2, c9_2, c9_1, c2_1 ---------------------------------------- (85) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) by IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, nil, x1) -> c4(PRODITER(nil, times(x1, head(nil)))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) ---------------------------------------- (86) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, nil, x1) -> c4(PRODITER(nil, times(x1, head(nil)))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, nil, x1) -> c4(PRODITER(nil, times(x1, head(nil)))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) K tuples:none Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, IFPROD_3, TIMESITER_4, PRODITER_2 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c5_2, c9_2, c9_1, c2_1, c4_1 ---------------------------------------- (87) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFPROD(false, nil, x1) -> c4(PRODITER(nil, times(x1, head(nil)))) ---------------------------------------- (88) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) K tuples:none Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, IFPROD_3, TIMESITER_4, PRODITER_2 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c5_2, c9_2, c9_1, c2_1, c4_1 ---------------------------------------- (89) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) ---------------------------------------- (90) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, IFPROD_3, TIMESITER_4, PRODITER_2 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c5_2, c9_2, c9_1, c2_1, c4_1 ---------------------------------------- (91) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) We considered the (Usable) Rules: tail(cons(z0, z1)) -> z1 tail(nil) -> nil And the Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(GE(x_1, x_2)) = 0 POL(IFPROD(x_1, x_2, x_3)) = x_2 POL(IFTIMES(x_1, x_2, x_3, x_4, x_5)) = x_2 POL(PLUS(x_1, x_2)) = 0 POL(PRODITER(x_1, x_2)) = x_1 POL(TIMES(x_1, x_2)) = 0 POL(TIMESITER(x_1, x_2, x_3, x_4)) = x_4 POL(c11(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1, x_2)) = x_1 + x_2 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(c9(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_2 POL(error) = [1] POL(false) = [1] POL(ge(x_1, x_2)) = [1] + x_1 + x_2 POL(head(x_1)) = [1] POL(ifTimes(x_1, x_2, x_3, x_4, x_5)) = [1] + x_1 + x_2 + x_3 + x_4 + x_5 POL(nil) = 0 POL(plus(x_1, x_2)) = [1] + x_1 + x_2 POL(s(x_1)) = 0 POL(tail(x_1)) = x_1 POL(times(x_1, x_2)) = [1] + x_1 POL(timesIter(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4 POL(true) = [1] ---------------------------------------- (92) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, IFPROD_3, TIMESITER_4, PRODITER_2 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c5_2, c9_2, c9_1, c2_1, c4_1 ---------------------------------------- (93) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) by IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, nil, x1) -> c5(PRODITER(tail(nil), times(x1, error)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(PRODITER(nil, times(x1, head(nil))), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) ---------------------------------------- (94) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, nil, x1) -> c5(PRODITER(tail(nil), times(x1, error)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(PRODITER(nil, times(x1, head(nil))), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, nil, x1) -> c5(PRODITER(tail(nil), times(x1, error)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(PRODITER(nil, times(x1, head(nil))), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_2, c9_1, c2_1, c4_1, c5_2 ---------------------------------------- (95) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (96) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, nil, x1) -> c5(PRODITER(tail(nil), times(x1, error)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, nil, x1) -> c5(PRODITER(tail(nil), times(x1, error)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_2, c9_1, c2_1, c4_1, c5_2, c5_1 ---------------------------------------- (97) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (98) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_2, c9_1, c2_1, c4_1, c5_2, c5_1, c_1 ---------------------------------------- (99) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) ---------------------------------------- (100) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_2, c9_1, c2_1, c4_1, c5_2, c5_1, c_1 ---------------------------------------- (101) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) We considered the (Usable) Rules: tail(cons(z0, z1)) -> z1 tail(nil) -> nil And the Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(GE(x_1, x_2)) = 0 POL(IFPROD(x_1, x_2, x_3)) = [2]x_1 + [2]x_1*x_3 + [2]x_1^2 + [2]x_2^2 POL(IFTIMES(x_1, x_2, x_3, x_4, x_5)) = 0 POL(PLUS(x_1, x_2)) = 0 POL(PRODITER(x_1, x_2)) = [2]x_1^2 POL(TIMES(x_1, x_2)) = 0 POL(TIMESITER(x_1, x_2, x_3, x_4)) = 0 POL(c(x_1)) = x_1 POL(c11(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c5(x_1, x_2)) = x_1 + x_2 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(c9(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [2] + x_2 POL(error) = 0 POL(false) = 0 POL(ge(x_1, x_2)) = 0 POL(head(x_1)) = 0 POL(ifTimes(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_3 + x_4 + x_5 + x_5^2 + x_4*x_5 + x_3*x_5 + x_2*x_5 + x_4^2 + x_3*x_4 + x_2*x_4 + x_2^2 + x_2*x_3 + x_3^2 POL(nil) = 0 POL(plus(x_1, x_2)) = 0 POL(s(x_1)) = 0 POL(tail(x_1)) = x_1 POL(times(x_1, x_2)) = 0 POL(timesIter(x_1, x_2, x_3, x_4)) = 0 POL(true) = [2] ---------------------------------------- (102) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_2, c9_1, c2_1, c4_1, c5_2, c5_1, c_1 ---------------------------------------- (103) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace TIMESITER(s(z1), x1, x2, s(z0)) -> c9(IFTIMES(ge(z0, z1), s(z1), x1, x2, s(z0)), GE(s(z0), s(z1))) by TIMESITER(s(0), x1, x2, s(z0)) -> c9(IFTIMES(true, s(0), x1, x2, s(z0)), GE(s(z0), s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) ---------------------------------------- (104) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(IFTIMES(true, s(0), x1, x2, s(z0)), GE(s(z0), s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(IFTIMES(true, s(0), x1, x2, s(z0)), GE(s(z0), s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c4_1, c5_2, c5_1, c_1, c9_2 ---------------------------------------- (105) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (106) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c4_1, c5_2, c5_1, c_1, c9_2 ---------------------------------------- (107) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0))) by IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(nil, timesIter(x1, head(nil), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) ---------------------------------------- (108) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(nil, timesIter(x1, head(nil), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(nil, timesIter(x1, head(nil), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c4_1, c5_2, c5_1, c_1, c9_2 ---------------------------------------- (109) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFPROD(false, nil, x1) -> c4(PRODITER(nil, timesIter(x1, head(nil), 0, 0))) ---------------------------------------- (110) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c4_1, c5_2, c5_1, c_1, c9_2 ---------------------------------------- (111) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) ---------------------------------------- (112) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c4_1, c5_2, c5_1, c_1, c9_2 ---------------------------------------- (113) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) We considered the (Usable) Rules: tail(cons(z0, z1)) -> z1 tail(nil) -> nil And the Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(GE(x_1, x_2)) = 0 POL(IFPROD(x_1, x_2, x_3)) = x_1 + x_2 POL(IFTIMES(x_1, x_2, x_3, x_4, x_5)) = x_2 POL(PLUS(x_1, x_2)) = 0 POL(PRODITER(x_1, x_2)) = x_1 POL(TIMES(x_1, x_2)) = 0 POL(TIMESITER(x_1, x_2, x_3, x_4)) = x_4 POL(c(x_1)) = x_1 POL(c11(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c5(x_1, x_2)) = x_1 + x_2 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(c9(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_2 POL(error) = [1] POL(false) = 0 POL(ge(x_1, x_2)) = x_2 POL(head(x_1)) = 0 POL(ifTimes(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_4 + x_5 POL(nil) = 0 POL(plus(x_1, x_2)) = [1] + x_1 + x_2 POL(s(x_1)) = 0 POL(tail(x_1)) = x_1 POL(times(x_1, x_2)) = [1] + x_1 POL(timesIter(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_3 + x_4 POL(true) = [1] ---------------------------------------- (114) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c4_1, c5_2, c5_1, c_1, c9_2 ---------------------------------------- (115) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) by IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) IFPROD(false, nil, x0) -> c4(PRODITER(nil, times(x0, error))) ---------------------------------------- (116) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, nil, x0) -> c4(PRODITER(nil, times(x0, error))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) K tuples: IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), times(x1, error))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c4_1, c5_2, c5_1, c_1, c9_2 ---------------------------------------- (117) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFPROD(false, nil, x0) -> c4(PRODITER(nil, times(x0, error))) ---------------------------------------- (118) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c4_1, c5_2, c5_1, c_1, c9_2 ---------------------------------------- (119) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), times(x1, z0))) by IFPROD(false, cons(z1, x1), z0) -> c4(PRODITER(tail(cons(z1, x1)), timesIter(z0, z1, 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) ---------------------------------------- (120) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c4_1, c5_2, c5_1, c_1, c9_2 ---------------------------------------- (121) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) We considered the (Usable) Rules: tail(cons(z0, z1)) -> z1 tail(nil) -> nil And the Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(GE(x_1, x_2)) = 0 POL(IFPROD(x_1, x_2, x_3)) = x_1 + x_2 POL(IFTIMES(x_1, x_2, x_3, x_4, x_5)) = x_2 POL(PLUS(x_1, x_2)) = 0 POL(PRODITER(x_1, x_2)) = x_1 POL(TIMES(x_1, x_2)) = 0 POL(TIMESITER(x_1, x_2, x_3, x_4)) = x_4 POL(c(x_1)) = x_1 POL(c11(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c5(x_1, x_2)) = x_1 + x_2 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(c9(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_2 POL(error) = [1] POL(false) = 0 POL(ge(x_1, x_2)) = x_2 POL(head(x_1)) = 0 POL(ifTimes(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_4 + x_5 POL(nil) = 0 POL(plus(x_1, x_2)) = [1] + x_1 + x_2 POL(s(x_1)) = 0 POL(tail(x_1)) = x_1 POL(times(x_1, x_2)) = [1] + x_1 POL(timesIter(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_3 + x_4 POL(true) = [1] ---------------------------------------- (122) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c4_1, c5_2, c5_1, c_1, c9_2 ---------------------------------------- (123) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) by IFPROD(false, cons(x0, x1), z0) -> c4(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) ---------------------------------------- (124) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c5_2, c5_1, c_1, c9_2, c4_1 ---------------------------------------- (125) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), timesIter(z0, head(x0), 0, 0)), TIMES(z0, head(x0))) by IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, nil, x1) -> c5(PRODITER(tail(nil), timesIter(x1, error, 0, 0)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(PRODITER(nil, timesIter(x1, head(nil), 0, 0)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) ---------------------------------------- (126) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, nil, x1) -> c5(PRODITER(tail(nil), timesIter(x1, error, 0, 0)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(PRODITER(nil, timesIter(x1, head(nil), 0, 0)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, nil, x1) -> c5(PRODITER(tail(nil), timesIter(x1, error, 0, 0)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(PRODITER(nil, timesIter(x1, head(nil), 0, 0)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c5_2, c5_1, c_1, c9_2, c4_1 ---------------------------------------- (127) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (128) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, nil, x1) -> c5(PRODITER(tail(nil), timesIter(x1, error, 0, 0)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, nil, x1) -> c5(PRODITER(tail(nil), timesIter(x1, error, 0, 0)), TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c5_2, c5_1, c_1, c9_2, c4_1 ---------------------------------------- (129) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (130) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c5_2, c5_1, c_1, c9_2, c4_1, c1_1 ---------------------------------------- (131) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) ---------------------------------------- (132) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c5_2, c5_1, c_1, c9_2, c4_1, c1_1 ---------------------------------------- (133) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) We considered the (Usable) Rules:none And the Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(GE(x_1, x_2)) = 0 POL(IFPROD(x_1, x_2, x_3)) = [1] + x_1 POL(IFTIMES(x_1, x_2, x_3, x_4, x_5)) = x_2 POL(PLUS(x_1, x_2)) = 0 POL(PRODITER(x_1, x_2)) = [1] POL(TIMES(x_1, x_2)) = 0 POL(TIMESITER(x_1, x_2, x_3, x_4)) = x_4 POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c11(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c5(x_1, x_2)) = x_1 + x_2 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(c9(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = x_2 POL(error) = [1] POL(false) = 0 POL(ge(x_1, x_2)) = x_2 POL(head(x_1)) = 0 POL(ifTimes(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_4 + x_5 POL(nil) = 0 POL(plus(x_1, x_2)) = [1] + x_1 + x_2 POL(s(x_1)) = 0 POL(tail(x_1)) = [1] + x_1 POL(times(x_1, x_2)) = [1] + x_1 POL(timesIter(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_4 POL(true) = [1] ---------------------------------------- (134) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c5_2, c5_1, c_1, c9_2, c4_1, c1_1 ---------------------------------------- (135) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) We considered the (Usable) Rules: tail(cons(z0, z1)) -> z1 tail(nil) -> nil And the Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(GE(x_1, x_2)) = 0 POL(IFPROD(x_1, x_2, x_3)) = [3]x_1 + [2]x_2 POL(IFTIMES(x_1, x_2, x_3, x_4, x_5)) = 0 POL(PLUS(x_1, x_2)) = 0 POL(PRODITER(x_1, x_2)) = [2]x_1 POL(TIMES(x_1, x_2)) = 0 POL(TIMESITER(x_1, x_2, x_3, x_4)) = 0 POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c11(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c5(x_1, x_2)) = x_1 + x_2 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(c9(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_2 POL(error) = 0 POL(false) = 0 POL(ge(x_1, x_2)) = 0 POL(head(x_1)) = 0 POL(ifTimes(x_1, x_2, x_3, x_4, x_5)) = [3] + [2]x_2 + [3]x_4 + [3]x_5 POL(nil) = 0 POL(plus(x_1, x_2)) = [2] + [3]x_2 POL(s(x_1)) = 0 POL(tail(x_1)) = x_1 POL(times(x_1, x_2)) = [3] + [2]x_1 POL(timesIter(x_1, x_2, x_3, x_4)) = [3]x_1 POL(true) = [3] ---------------------------------------- (136) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c5_2, c5_1, c_1, c9_2, c4_1, c1_1 ---------------------------------------- (137) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), times(x1, z0)), TIMES(x1, head(cons(z0, z1)))) by IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), timesIter(z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) ---------------------------------------- (138) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c5_2, c5_1, c_1, c9_2, c4_1, c1_1 ---------------------------------------- (139) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) We considered the (Usable) Rules: tail(cons(z0, z1)) -> z1 tail(nil) -> nil And the Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(GE(x_1, x_2)) = 0 POL(IFPROD(x_1, x_2, x_3)) = x_1 + x_2 POL(IFTIMES(x_1, x_2, x_3, x_4, x_5)) = x_2 POL(PLUS(x_1, x_2)) = 0 POL(PRODITER(x_1, x_2)) = x_1 POL(TIMES(x_1, x_2)) = 0 POL(TIMESITER(x_1, x_2, x_3, x_4)) = x_4 POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c11(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c5(x_1, x_2)) = x_1 + x_2 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(c9(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_2 POL(error) = [1] POL(false) = 0 POL(ge(x_1, x_2)) = x_2 POL(head(x_1)) = 0 POL(ifTimes(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_4 + x_5 POL(nil) = 0 POL(plus(x_1, x_2)) = [1] + x_1 + x_2 POL(s(x_1)) = 0 POL(tail(x_1)) = x_1 POL(times(x_1, x_2)) = [1] + x_1 POL(timesIter(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_4 POL(true) = [1] ---------------------------------------- (140) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c5_2, c5_1, c_1, c9_2, c4_1, c1_1 ---------------------------------------- (141) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) by IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) ---------------------------------------- (142) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c5_1, c_1, c9_2, c4_1, c5_2, c1_1 ---------------------------------------- (143) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) by IFPROD(false, nil, x0) -> c5(TIMES(x0, error)) ---------------------------------------- (144) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, x0) -> c5(TIMES(x0, error)) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, times(x1, head(cons(z0, z1))))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, times(x1, head(cons(z0, z1)))), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c5_1, c_1, c9_2, c4_1, c5_2, c1_1 ---------------------------------------- (145) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: IFPROD(false, nil, x0) -> c5(TIMES(x0, error)) ---------------------------------------- (146) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c_1, c9_2, c4_1, c5_2, c5_1, c1_1 ---------------------------------------- (147) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) by IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) IFPROD(false, nil, x0) -> c(PRODITER(nil, times(x0, error))) ---------------------------------------- (148) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) IFPROD(false, nil, x0) -> c(PRODITER(nil, times(x0, error))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(PRODITER(tail(nil), times(x1, error))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c_1, c9_2, c4_1, c5_2, c5_1, c1_1 ---------------------------------------- (149) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFPROD(false, nil, x0) -> c(PRODITER(nil, times(x0, error))) ---------------------------------------- (150) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c_1, c9_2, c4_1, c5_2, c5_1, c1_1 ---------------------------------------- (151) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) by IFPROD(false, nil, x0) -> c(TIMES(x0, error)) ---------------------------------------- (152) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) IFPROD(false, nil, x0) -> c(TIMES(x0, error)) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c9_2, c4_1, c5_2, c5_1, c1_1, c_1 ---------------------------------------- (153) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: IFPROD(false, nil, x0) -> c(TIMES(x0, error)) ---------------------------------------- (154) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c9_2, c4_1, c5_2, c5_1, c1_1, c_1 ---------------------------------------- (155) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace TIMESITER(s(s(z1)), x1, x2, s(s(z0))) -> c9(IFTIMES(ge(z0, z1), s(s(z1)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(z1)))) by TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(IFTIMES(true, s(s(0)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) ---------------------------------------- (156) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(IFTIMES(true, s(s(0)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(IFTIMES(true, s(s(0)), x1, x2, s(s(z0))), GE(s(s(z0)), s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c9_2, c4_1, c5_2, c5_1, c1_1, c_1 ---------------------------------------- (157) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (158) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c9_2, c4_1, c5_2, c5_1, c1_1, c_1 ---------------------------------------- (159) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) by IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) ---------------------------------------- (160) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c9_2, c4_1, c5_2, c5_1, c1_1, c_1 ---------------------------------------- (161) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) by IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) ---------------------------------------- (162) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c9_2, c4_1, c5_2, c5_1, c1_1, c_1 ---------------------------------------- (163) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) by IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) ---------------------------------------- (164) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c9_2, c4_1, c5_2, c5_1, c1_1, c_1 ---------------------------------------- (165) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) by IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) ---------------------------------------- (166) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c9_2, c4_1, c5_2, c5_1, c1_1, c_1 ---------------------------------------- (167) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, cons(z1, x1), z0) -> c4(PRODITER(tail(cons(z1, x1)), timesIter(z0, z1, 0, 0))) by IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) ---------------------------------------- (168) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c9_2, c4_1, c5_2, c5_1, c1_1, c_1 ---------------------------------------- (169) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) by IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) ---------------------------------------- (170) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, IFTIMES_5, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3 Compound Symbols: c7_1, c8_1, c11_2, c20_1, c9_1, c2_1, c9_2, c4_1, c5_2, c5_1, c1_1, c_1 ---------------------------------------- (171) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) by IFTIMES(false, s(x0), x1, x2, 0) -> c11(TIMESITER(s(x0), x1, plus(x1, x2), s(0)), PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c11(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0))), PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0)))), PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) ---------------------------------------- (172) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(x0), x1, x2, 0) -> c11(TIMESITER(s(x0), x1, plus(x1, x2), s(0)), PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c11(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0))), PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0)))), PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c9(IFTIMES(false, s(s(z0)), x1, x2, s(0)), GE(s(0), s(s(z0)))) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c9(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0))), GE(s(s(0)), s(s(s(z0))))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(x0), x1, x2, 0) -> c11(TIMESITER(s(x0), x1, plus(x1, x2), s(0)), PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c11(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0))), PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0)))), PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3, IFTIMES_5 Compound Symbols: c7_1, c8_1, c20_1, c9_1, c2_1, c9_2, c4_1, c5_2, c5_1, c1_1, c_1, c11_2 ---------------------------------------- (173) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (174) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, GE_2, TIMESITER_4, PRODITER_2, IFPROD_3, IFTIMES_5 Compound Symbols: c7_1, c8_1, c20_1, c9_1, c2_1, c4_1, c5_2, c5_1, c1_1, c_1, c9_2, c11_2, c3_1 ---------------------------------------- (175) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace TIMESITER(s(z0), x1, x2, 0) -> c9(IFTIMES(false, s(z0), x1, x2, 0)) by TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) ---------------------------------------- (176) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5 Compound Symbols: c7_1, c8_1, c20_1, c2_1, c9_1, c4_1, c5_2, c5_1, c1_1, c_1, c9_2, c11_2, c3_1 ---------------------------------------- (177) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, cons(x0, x1), z0) -> c4(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0))) by IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) ---------------------------------------- (178) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5 Compound Symbols: c7_1, c8_1, c20_1, c2_1, c9_1, c4_1, c5_2, c5_1, c1_1, c_1, c9_2, c11_2, c3_1 ---------------------------------------- (179) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) by IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) ---------------------------------------- (180) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5 Compound Symbols: c7_1, c8_1, c20_1, c2_1, c9_1, c4_1, c5_2, c5_1, c1_1, c_1, c9_2, c11_2, c3_1 ---------------------------------------- (181) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace TIMESITER(s(x0), x1, x2, s(x3)) -> c9(GE(s(x3), s(x0))) by TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) ---------------------------------------- (182) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5 Compound Symbols: c7_1, c8_1, c20_1, c2_1, c9_1, c4_1, c5_2, c5_1, c1_1, c_1, c9_2, c11_2, c3_1 ---------------------------------------- (183) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace TIMESITER(s(0), x1, x2, s(z0)) -> c9(GE(s(z0), s(0))) by TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) ---------------------------------------- (184) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5 Compound Symbols: c7_1, c8_1, c20_1, c2_1, c4_1, c5_2, c5_1, c1_1, c_1, c9_2, c9_1, c11_2, c3_1 ---------------------------------------- (185) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace IFPROD(false, x0, z0) -> c4(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0))) by IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) ---------------------------------------- (186) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5 Compound Symbols: c7_1, c8_1, c20_1, c2_1, c5_2, c5_1, c1_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1 ---------------------------------------- (187) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0))) by IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) ---------------------------------------- (188) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) S tuples: PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: PLUS_2, TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5 Compound Symbols: c7_1, c8_1, c20_1, c2_1, c5_2, c5_1, c1_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1 ---------------------------------------- (189) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) by PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) ---------------------------------------- (190) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c5_2, c5_1, c1_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1 ---------------------------------------- (191) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) by IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) ---------------------------------------- (192) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c5_2, c5_1, c1_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1 ---------------------------------------- (193) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) by IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) ---------------------------------------- (194) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c5_2, c5_1, c1_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1 ---------------------------------------- (195) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) by IFPROD(false, nil, z0) -> c5(TIMES(z0, error)) ---------------------------------------- (196) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(x1, z0, 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c5(TIMES(z0, error)) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, nil, x1) -> c5(TIMES(x1, head(nil))) IFPROD(false, nil, x1) -> c4(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, cons(z0, z1), x1) -> c4(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, times(x2, z0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c5_2, c5_1, c1_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1 ---------------------------------------- (197) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: IFPROD(false, nil, z0) -> c5(TIMES(z0, error)) ---------------------------------------- (198) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), timesIter(z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c5_1, c1_1, c5_2, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1 ---------------------------------------- (199) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace IFPROD(false, x0, x1) -> c5(TIMES(x1, head(x0))) by IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) ---------------------------------------- (200) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), timesIter(z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c1_1, c5_2, c5_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1 ---------------------------------------- (201) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) by IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) ---------------------------------------- (202) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), timesIter(z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c1_1, c5_2, c5_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1 ---------------------------------------- (203) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) by IFPROD(false, nil, z0) -> c1(TIMES(z0, error)) ---------------------------------------- (204) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), timesIter(z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, nil, z0) -> c1(TIMES(z0, error)) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, nil, x1) -> c1(PRODITER(tail(nil), timesIter(x1, error, 0, 0))) IFPROD(false, nil, x1) -> c1(TIMES(x1, head(nil))) IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c5_2, c5_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1, c1_1 ---------------------------------------- (205) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: IFPROD(false, nil, z0) -> c1(TIMES(z0, error)) ---------------------------------------- (206) Obligation: Complexity Dependency Tuples Problem Rules: plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 times(z0, z1) -> timesIter(z0, z1, 0, 0) head(nil) -> error head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), timesIter(z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: plus_2, tail_1, times_2, head_1, timesIter_4, ifTimes_5, ge_2 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c5_2, c5_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1, c1_1 ---------------------------------------- (207) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: head(nil) -> error ---------------------------------------- (208) Obligation: Complexity Dependency Tuples Problem Rules: tail(cons(z0, z1)) -> z1 tail(nil) -> nil timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) head(cons(z0, z1)) -> z0 times(z0, z1) -> timesIter(z0, z1, 0, 0) Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), timesIter(z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: tail_1, timesIter_4, ifTimes_5, ge_2, plus_2, head_1, times_2 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c5_2, c5_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1, c1_1 ---------------------------------------- (209) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), timesIter(z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) by IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) ---------------------------------------- (210) Obligation: Complexity Dependency Tuples Problem Rules: tail(cons(z0, z1)) -> z1 tail(nil) -> nil timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) head(cons(z0, z1)) -> z0 times(z0, z1) -> timesIter(z0, z1, 0, 0) Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: tail_1, timesIter_4, ifTimes_5, ge_2, plus_2, head_1, times_2 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c5_2, c5_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1, c1_1 ---------------------------------------- (211) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) by IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(x1, timesIter(z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) ---------------------------------------- (212) Obligation: Complexity Dependency Tuples Problem Rules: tail(cons(z0, z1)) -> z1 tail(nil) -> nil timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) head(cons(z0, z1)) -> z0 times(z0, z1) -> timesIter(z0, z1, 0, 0) Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: tail_1, timesIter_4, ifTimes_5, ge_2, plus_2, head_1, times_2 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c5_1, c5_2, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1, c1_1 ---------------------------------------- (213) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: times(z0, z1) -> timesIter(z0, z1, 0, 0) ---------------------------------------- (214) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c5_1, c5_2, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1, c1_1 ---------------------------------------- (215) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) by IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) ---------------------------------------- (216) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c5_2, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1, c1_1, c5_1 ---------------------------------------- (217) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, timesIter(z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) by IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) ---------------------------------------- (218) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c5_2, c7_1, c1_1, c5_1 ---------------------------------------- (219) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), timesIter(z0, error, 0, 0))) by IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, nil, x0) -> c(PRODITER(nil, timesIter(x0, error, 0, 0))) ---------------------------------------- (220) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, nil, x0) -> c(PRODITER(nil, timesIter(x0, error, 0, 0))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, cons(z0, z1), x1) -> c5(PRODITER(z1, timesIter(x1, head(cons(z0, z1)), 0, 0)), TIMES(x1, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, times(x2, z0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c9_2, c9_1, c4_1, c11_2, c3_1, c5_2, c7_1, c1_1, c5_1, c_1 ---------------------------------------- (221) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFPROD(false, nil, x0) -> c(PRODITER(nil, timesIter(x0, error, 0, 0))) ---------------------------------------- (222) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) K tuples: IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c9_2, c9_1, c4_1, c11_2, c3_1, c5_2, c7_1, c1_1, c5_1, c_1 ---------------------------------------- (223) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace TIMESITER(s(s(s(z1))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(ge(z0, z1), s(s(s(z1))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(z1))))) by TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(true, s(s(s(0))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c9(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0)))), GE(s(s(s(0))), s(s(s(s(z0)))))) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) ---------------------------------------- (224) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(true, s(s(s(0))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c9(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0)))), GE(s(s(s(0))), s(s(s(s(z0)))))) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(IFTIMES(true, s(s(s(0))), x1, x2, s(s(s(z0)))), GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c9(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0)))), GE(s(s(s(0))), s(s(s(s(z0)))))) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) K tuples: IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c9_1, c4_1, c11_2, c3_1, c5_2, c7_1, c1_1, c5_1, c_1, c9_2 ---------------------------------------- (225) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (226) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c9(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0)))), GE(s(s(s(0))), s(s(s(s(z0)))))) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c9(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0)))), GE(s(s(s(0))), s(s(s(s(z0)))))) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) K tuples: IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c9_1, c4_1, c11_2, c3_1, c5_2, c7_1, c1_1, c5_1, c_1, c9_2 ---------------------------------------- (227) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (228) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) K tuples: IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c9_1, c4_1, c11_2, c3_1, c5_2, c7_1, c1_1, c5_1, c_1, c9_2, c6_1 ---------------------------------------- (229) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, nil, z0) -> c4(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) by IFPROD(false, nil, 0) -> c4(PRODITER(tail(nil), ifTimes(true, 0, error, 0, 0))) IFPROD(false, nil, s(z0)) -> c4(PRODITER(tail(nil), ifTimes(false, s(z0), error, 0, 0))) IFPROD(false, nil, x0) -> c4(PRODITER(nil, ifTimes(ge(0, x0), x0, error, 0, 0))) ---------------------------------------- (230) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) IFPROD(false, nil, 0) -> c4(PRODITER(tail(nil), ifTimes(true, 0, error, 0, 0))) IFPROD(false, nil, s(z0)) -> c4(PRODITER(tail(nil), ifTimes(false, s(z0), error, 0, 0))) IFPROD(false, nil, x0) -> c4(PRODITER(nil, ifTimes(ge(0, x0), x0, error, 0, 0))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) K tuples: IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c9_1, c4_1, c11_2, c3_1, c5_2, c7_1, c1_1, c5_1, c_1, c9_2, c6_1 ---------------------------------------- (231) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: IFPROD(false, nil, x0) -> c4(PRODITER(nil, ifTimes(ge(0, x0), x0, error, 0, 0))) ---------------------------------------- (232) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) IFPROD(false, nil, 0) -> c4(PRODITER(tail(nil), ifTimes(true, 0, error, 0, 0))) IFPROD(false, nil, s(z0)) -> c4(PRODITER(tail(nil), ifTimes(false, s(z0), error, 0, 0))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) K tuples: IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c9_1, c4_1, c11_2, c3_1, c5_2, c7_1, c1_1, c5_1, c_1, c9_2, c6_1 ---------------------------------------- (233) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(tail(cons(z0, z1)), ifTimes(ge(0, z2), z2, z0, 0, 0))) by IFPROD(false, cons(x0, x1), 0) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(true, 0, x0, 0, 0))) IFPROD(false, cons(x0, x1), s(z0)) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(false, s(z0), x0, 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, ifTimes(ge(0, x2), x2, z0, 0, 0))) ---------------------------------------- (234) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) IFPROD(false, nil, 0) -> c4(PRODITER(tail(nil), ifTimes(true, 0, error, 0, 0))) IFPROD(false, nil, s(z0)) -> c4(PRODITER(tail(nil), ifTimes(false, s(z0), error, 0, 0))) IFPROD(false, cons(x0, x1), 0) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(true, 0, x0, 0, 0))) IFPROD(false, cons(x0, x1), s(z0)) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(false, s(z0), x0, 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, ifTimes(ge(0, x2), x2, z0, 0, 0))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) IFPROD(false, cons(x0, x1), 0) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(true, 0, x0, 0, 0))) IFPROD(false, cons(x0, x1), s(z0)) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(false, s(z0), x0, 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, ifTimes(ge(0, x2), x2, z0, 0, 0))) K tuples: IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c9_1, c4_1, c11_2, c3_1, c5_2, c7_1, c1_1, c5_1, c_1, c9_2, c6_1 ---------------------------------------- (235) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, ifTimes(ge(0, x2), x2, z0, 0, 0))) We considered the (Usable) Rules: tail(cons(z0, z1)) -> z1 tail(nil) -> nil And the Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) IFPROD(false, nil, 0) -> c4(PRODITER(tail(nil), ifTimes(true, 0, error, 0, 0))) IFPROD(false, nil, s(z0)) -> c4(PRODITER(tail(nil), ifTimes(false, s(z0), error, 0, 0))) IFPROD(false, cons(x0, x1), 0) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(true, 0, x0, 0, 0))) IFPROD(false, cons(x0, x1), s(z0)) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(false, s(z0), x0, 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, ifTimes(ge(0, x2), x2, z0, 0, 0))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(GE(x_1, x_2)) = 0 POL(IFPROD(x_1, x_2, x_3)) = x_1 + x_2 POL(IFTIMES(x_1, x_2, x_3, x_4, x_5)) = x_2 + x_5 POL(PLUS(x_1, x_2)) = 0 POL(PRODITER(x_1, x_2)) = x_1 POL(TIMES(x_1, x_2)) = 0 POL(TIMESITER(x_1, x_2, x_3, x_4)) = x_4 POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c11(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c5(x_1, x_2)) = x_1 + x_2 POL(c6(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(c9(x_1, x_2)) = x_1 + x_2 POL(cons(x_1, x_2)) = [1] + x_2 POL(error) = [1] POL(false) = 0 POL(ge(x_1, x_2)) = 0 POL(head(x_1)) = [1] POL(ifTimes(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_4 + x_5 POL(nil) = 0 POL(plus(x_1, x_2)) = [1] + x_1 + x_2 POL(s(x_1)) = 0 POL(tail(x_1)) = x_1 POL(timesIter(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_3 POL(true) = [1] ---------------------------------------- (236) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) IFPROD(false, nil, 0) -> c4(PRODITER(tail(nil), ifTimes(true, 0, error, 0, 0))) IFPROD(false, nil, s(z0)) -> c4(PRODITER(tail(nil), ifTimes(false, s(z0), error, 0, 0))) IFPROD(false, cons(x0, x1), 0) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(true, 0, x0, 0, 0))) IFPROD(false, cons(x0, x1), s(z0)) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(false, s(z0), x0, 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, ifTimes(ge(0, x2), x2, z0, 0, 0))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) IFPROD(false, cons(x0, x1), 0) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(true, 0, x0, 0, 0))) IFPROD(false, cons(x0, x1), s(z0)) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(false, s(z0), x0, 0, 0))) K tuples: IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, ifTimes(ge(0, x2), x2, z0, 0, 0))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c9_1, c4_1, c11_2, c3_1, c5_2, c7_1, c1_1, c5_1, c_1, c9_2, c6_1 ---------------------------------------- (237) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0))) by IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, ifTimes(ge(0, x2), x2, z0, 0, 0))) IFPROD(false, cons(x0, x1), 0) -> c4(PRODITER(x1, ifTimes(true, 0, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), s(z0)) -> c4(PRODITER(x1, ifTimes(false, s(z0), head(cons(x0, x1)), 0, 0))) ---------------------------------------- (238) Obligation: Complexity Dependency Tuples Problem Rules: head(cons(z0, z1)) -> z0 timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) ifTimes(true, z0, z1, z2, z3) -> z2 ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) ge(z0, 0) -> true ge(0, s(z0)) -> false ge(s(z0), s(z1)) -> ge(z0, z1) plus(0, z0) -> z0 plus(s(z0), z1) -> s(plus(z0, z1)) tail(nil) -> nil tail(cons(z0, z1)) -> z1 Tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(z1, timesIter(z2, head(cons(z0, z1)), 0, 0)), TIMES(z2, z0)) IFPROD(false, nil, z0) -> c1(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) IFPROD(false, cons(z1, x1), z0) -> c5(PRODITER(tail(cons(z1, x1)), ifTimes(ge(0, z0), z0, z1, 0, 0)), TIMES(z0, head(cons(z1, x1)))) IFPROD(false, cons(z0, z1), x2) -> c5(PRODITER(z1, timesIter(x2, z0, 0, 0)), TIMES(x2, head(cons(z0, z1)))) IFPROD(false, cons(z0, z1), x2) -> c5(TIMES(x2, z0)) IFPROD(false, cons(x0, x1), z0) -> c5(PRODITER(x1, ifTimes(ge(0, z0), z0, head(cons(x0, x1)), 0, 0)), TIMES(z0, head(cons(x0, x1)))) IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, nil, z0) -> c(PRODITER(tail(nil), ifTimes(ge(0, z0), z0, error, 0, 0))) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) IFPROD(false, nil, 0) -> c4(PRODITER(tail(nil), ifTimes(true, 0, error, 0, 0))) IFPROD(false, nil, s(z0)) -> c4(PRODITER(tail(nil), ifTimes(false, s(z0), error, 0, 0))) IFPROD(false, cons(x0, x1), 0) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(true, 0, x0, 0, 0))) IFPROD(false, cons(x0, x1), s(z0)) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(false, s(z0), x0, 0, 0))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, ifTimes(ge(0, x2), x2, z0, 0, 0))) IFPROD(false, cons(x0, x1), 0) -> c4(PRODITER(x1, ifTimes(true, 0, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), s(z0)) -> c4(PRODITER(x1, ifTimes(false, s(z0), head(cons(x0, x1)), 0, 0))) S tuples: TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) GE(s(z0), s(z1)) -> c20(GE(z0, z1)) PRODITER(cons(z0, z1), x1) -> c2(IFPROD(false, cons(z0, z1), x1)) TIMESITER(s(s(x0)), x1, x2, s(s(x3))) -> c9(GE(s(s(x3)), s(s(x0)))) TIMESITER(s(s(0)), x1, x2, s(s(z0))) -> c9(GE(s(s(z0)), s(s(0)))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c11(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(s(x3))))), PLUS(x1, x2)) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(IFTIMES(false, s(s(z0)), x1, x2, s(0))) TIMESITER(s(s(z0)), x1, x2, s(0)) -> c3(GE(s(0), s(s(z0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(IFTIMES(false, s(s(s(z0))), x1, x2, s(s(0)))) TIMESITER(s(s(s(z0))), x1, x2, s(s(0))) -> c3(GE(s(s(0)), s(s(s(z0))))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(TIMESITER(s(x0), x1, plus(x1, x2), s(0))) IFTIMES(false, s(x0), x1, x2, 0) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(TIMESITER(s(s(x0)), x1, plus(x1, x2), s(s(0)))) IFTIMES(false, s(s(x0)), x1, x2, s(0)) -> c3(PLUS(x1, x2)) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(TIMESITER(s(s(s(x0))), x1, plus(x1, x2), s(s(s(0))))) IFTIMES(false, s(s(s(x0))), x1, x2, s(s(0))) -> c3(PLUS(x1, x2)) TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0)) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(s(x3))))) -> c9(GE(s(s(s(s(x3)))), s(s(s(x0))))) TIMESITER(s(x0), x1, y0, s(0)) -> c9(GE(s(0), s(x0))) TIMESITER(s(s(x0)), x1, y0, s(s(0))) -> c9(GE(s(s(0)), s(s(x0)))) TIMESITER(s(s(s(x0))), x1, y0, s(s(s(0)))) -> c9(GE(s(s(s(0))), s(s(s(x0))))) TIMESITER(s(0), x1, y0, s(0)) -> c9(GE(s(0), s(0))) IFPROD(false, cons(x0, x1), x2) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0))) IFPROD(false, cons(x0, x1), x2) -> c5(PRODITER(tail(cons(x0, x1)), ifTimes(ge(0, x2), x2, head(cons(x0, x1)), 0, 0)), TIMES(x2, head(cons(x0, x1)))) PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1)) IFPROD(false, cons(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0)) TIMESITER(s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))) -> c9(IFTIMES(ge(z0, z1), s(s(s(s(z1)))), x1, x2, s(s(s(s(z0))))), GE(s(s(s(s(z0)))), s(s(s(s(z1)))))) TIMESITER(s(s(s(x0))), x1, x2, s(s(s(x3)))) -> c9(GE(s(s(s(x3))), s(s(s(x0))))) TIMESITER(s(s(s(0))), x1, x2, s(s(s(z0)))) -> c9(GE(s(s(s(z0))), s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(IFTIMES(false, s(s(s(s(z0)))), x1, x2, s(s(s(0))))) TIMESITER(s(s(s(s(z0)))), x1, x2, s(s(s(0)))) -> c6(GE(s(s(s(0))), s(s(s(s(z0)))))) IFPROD(false, cons(x0, x1), 0) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(true, 0, x0, 0, 0))) IFPROD(false, cons(x0, x1), s(z0)) -> c4(PRODITER(tail(cons(x0, x1)), ifTimes(false, s(z0), x0, 0, 0))) K tuples: IFPROD(false, cons(x0, x1), x2) -> c5(TIMES(x2, head(cons(x0, x1)))) IFPROD(false, cons(z0, z1), x2) -> c4(PRODITER(z1, ifTimes(ge(0, x2), x2, z0, 0, 0))) Defined Rule Symbols: head_1, timesIter_4, ifTimes_5, ge_2, plus_2, tail_1 Defined Pair Symbols: TIMES_2, GE_2, PRODITER_2, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2 Compound Symbols: c8_1, c20_1, c2_1, c9_1, c4_1, c11_2, c3_1, c5_2, c7_1, c1_1, c5_1, c_1, c9_2, c6_1