KILLED
proof of input_zyCbKXs3vM.trs
# AProVE Commit ID: 5b976082cb74a395683ed8cc7acf94bd611ab29f fuhs 20230524 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) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(4) CdtProblem
    (5) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (6) CpxRelTRS
    (7) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) CpxRelTRS
    (9) TypeInferenceProof [BOTH BOUNDS(ID, ID), 10 ms]
    (10) typed CpxTrs
    (11) OrderProof [LOWER BOUND(ID), 0 ms]
    (12) typed CpxTrs
    (13) RewriteLemmaProof [LOWER BOUND(ID), 1208 ms]
    (14) BEST
        (15) proven lower bound
            (16) LowerBoundPropagationProof [FINISHED, 0 ms]
            (17) BOUNDS(n^1, INF)
        (18) typed CpxTrs
            (19) RewriteLemmaProof [LOWER BOUND(ID), 44 ms]
            (20) typed CpxTrs
            (21) RewriteLemmaProof [LOWER BOUND(ID), 16 ms]
            (22) typed CpxTrs
            (23) RewriteLemmaProof [LOWER BOUND(ID), 112 ms]
            (24) typed CpxTrs
            (25) RewriteLemmaProof [LOWER BOUND(ID), 66 ms]
            (26) typed CpxTrs
            (27) RewriteLemmaProof [LOWER BOUND(ID), 161 ms]
            (28) typed CpxTrs
(29) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(30) CpxTRS
(31) CpxTrsToCdtProof [UPPER BOUND(ID), 1 ms]
(32) CdtProblem
    (33) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (34) CdtProblem
    (35) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (36) CdtProblem
    (37) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (38) CdtProblem
    (39) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (40) CpxRelTRS
        (41) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
        (42) CpxTRS
        (43) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (44) CpxWeightedTrs
            (45) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
            (46) CpxTypedWeightedTrs
            (47) CompletionProof [UPPER BOUND(ID), 0 ms]
            (48) CpxTypedWeightedCompleteTrs
                (49) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
                (50) CpxTypedWeightedCompleteTrs
                (51) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
                (52) CpxRNTS
                (53) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
                (54) CpxRNTS
                (55) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
                (56) CpxRNTS
                (57) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (58) CpxRNTS
                (59) IntTrsBoundProof [UPPER BOUND(ID), 149 ms]
                (60) CpxRNTS
                (61) IntTrsBoundProof [UPPER BOUND(ID), 66 ms]
                (62) CpxRNTS
                (63) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (64) CpxRNTS
                (65) IntTrsBoundProof [UPPER BOUND(ID), 69 ms]
                (66) CpxRNTS
                (67) IntTrsBoundProof [UPPER BOUND(ID), 2 ms]
                (68) CpxRNTS
                (69) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (70) CpxRNTS
                (71) IntTrsBoundProof [UPPER BOUND(ID), 159 ms]
                (72) CpxRNTS
                (73) IntTrsBoundProof [UPPER BOUND(ID), 32 ms]
                (74) CpxRNTS
                (75) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (76) CpxRNTS
                (77) IntTrsBoundProof [UPPER BOUND(ID), 411 ms]
                (78) CpxRNTS
                (79) IntTrsBoundProof [UPPER BOUND(ID), 115 ms]
                (80) CpxRNTS
                (81) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (82) CpxRNTS
                (83) IntTrsBoundProof [UPPER BOUND(ID), 151 ms]
                (84) CpxRNTS
                (85) IntTrsBoundProof [UPPER BOUND(ID), 14 ms]
                (86) CpxRNTS
                (87) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (88) CpxRNTS
                (89) IntTrsBoundProof [UPPER BOUND(ID), 141 ms]
                (90) CpxRNTS
                (91) IntTrsBoundProof [UPPER BOUND(ID), 52 ms]
                (92) CpxRNTS
                (93) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (94) CpxRNTS
                (95) IntTrsBoundProof [UPPER BOUND(ID), 97 ms]
                (96) CpxRNTS
                (97) IntTrsBoundProof [UPPER BOUND(ID), 74 ms]
                (98) CpxRNTS
                (99) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (100) CpxRNTS
                (101) IntTrsBoundProof [UPPER BOUND(ID), 2626 ms]
                (102) CpxRNTS
                (103) IntTrsBoundProof [UPPER BOUND(ID), 1679 ms]
                (104) CpxRNTS
            (105) CompletionProof [UPPER BOUND(ID), 0 ms]
            (106) CpxTypedWeightedCompleteTrs
                (107) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
                (108) CpxRNTS
    (109) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (110) CdtProblem
        (111) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (112) CdtProblem
        (113) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (114) CdtProblem
        (115) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (116) CdtProblem
        (117) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (118) CdtProblem
        (119) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
        (120) CdtProblem
        (121) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (122) CdtProblem
        (123) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (124) CdtProblem
        (125) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
        (126) CdtProblem
        (127) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 31 ms]
        (128) CdtProblem
        (129) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 3 ms]
        (130) CdtProblem
        (131) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (132) CdtProblem
        (133) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (134) CdtProblem
        (135) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
        (136) CdtProblem
        (137) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 46 ms]
        (138) CdtProblem
        (139) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (140) CdtProblem
        (141) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (142) CdtProblem
        (143) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (144) CdtProblem
        (145) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (146) CdtProblem
        (147) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
        (148) CdtProblem
        (149) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 64 ms]
        (150) CdtProblem
        (151) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (152) CdtProblem
        (153) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (154) CdtProblem
        (155) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (156) CdtProblem
        (157) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 48 ms]
        (158) CdtProblem
        (159) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (160) CdtProblem
        (161) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (162) CdtProblem
        (163) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (164) CdtProblem
        (165) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (166) CdtProblem
        (167) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
        (168) CdtProblem
        (169) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 46 ms]
        (170) CdtProblem
        (171) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 46 ms]
        (172) CdtProblem
        (173) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (174) CdtProblem
        (175) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 29 ms]
        (176) CdtProblem
        (177) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (178) CdtProblem
        (179) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (180) CdtProblem
        (181) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
        (182) CdtProblem
        (183) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (184) CdtProblem
        (185) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (186) CdtProblem
        (187) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (188) CdtProblem
        (189) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
        (190) CdtProblem
        (191) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (192) CdtProblem
        (193) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (194) CdtProblem
        (195) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (196) CdtProblem
        (197) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (198) CdtProblem
        (199) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (200) CdtProblem
        (201) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (202) CdtProblem
        (203) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (204) CdtProblem
        (205) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (206) CdtProblem
        (207) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (208) CdtProblem
        (209) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (210) CdtProblem
        (211) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (212) CdtProblem
        (213) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (214) CdtProblem
        (215) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (216) CdtProblem
        (217) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (218) CdtProblem
        (219) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (220) CdtProblem
        (221) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (222) CdtProblem
        (223) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (224) CdtProblem
        (225) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (226) CdtProblem
        (227) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (228) CdtProblem
        (229) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (230) CdtProblem
        (231) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (232) CdtProblem
        (233) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (234) CdtProblem
        (235) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
        (236) CdtProblem
        (237) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (238) CdtProblem
        (239) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (240) CdtProblem
        (241) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
        (242) CdtProblem
        (243) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
        (244) CdtProblem
        (245) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (246) CdtProblem
        (247) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (248) CdtProblem
        (249) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
        (250) CdtProblem
        (251) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (252) CdtProblem
        (253) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (254) CdtProblem
        (255) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (256) CdtProblem
        (257) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (258) CdtProblem
        (259) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (260) CdtProblem
        (261) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (262) CdtProblem
        (263) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (264) CdtProblem
        (265) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (266) CdtProblem
        (267) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (268) CdtProblem
        (269) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (270) CdtProblem
        (271) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 63 ms]
        (272) CdtProblem
        (273) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (274) CdtProblem
        (275) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (276) CdtProblem
(277) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 1 ms]
(278) CpxWeightedTrs
    (279) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (280) CpxTypedWeightedTrs
    (281) CompletionProof [UPPER BOUND(ID), 0 ms]
    (282) CpxTypedWeightedCompleteTrs
        (283) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (284) CpxTypedWeightedCompleteTrs
        (285) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (286) CpxRNTS
        (287) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (288) CpxRNTS
        (289) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
        (290) CpxRNTS
        (291) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (292) CpxRNTS
        (293) IntTrsBoundProof [UPPER BOUND(ID), 157 ms]
        (294) CpxRNTS
        (295) IntTrsBoundProof [UPPER BOUND(ID), 17 ms]
        (296) CpxRNTS
        (297) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (298) CpxRNTS
        (299) IntTrsBoundProof [UPPER BOUND(ID), 111 ms]
        (300) CpxRNTS
        (301) IntTrsBoundProof [UPPER BOUND(ID), 56 ms]
        (302) CpxRNTS
        (303) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (304) CpxRNTS
        (305) IntTrsBoundProof [UPPER BOUND(ID), 295 ms]
        (306) CpxRNTS
        (307) IntTrsBoundProof [UPPER BOUND(ID), 137 ms]
        (308) CpxRNTS
        (309) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (310) CpxRNTS
        (311) IntTrsBoundProof [UPPER BOUND(ID), 111 ms]
        (312) CpxRNTS
        (313) IntTrsBoundProof [UPPER BOUND(ID), 3 ms]
        (314) CpxRNTS
        (315) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (316) CpxRNTS
        (317) IntTrsBoundProof [UPPER BOUND(ID), 232 ms]
        (318) CpxRNTS
        (319) IntTrsBoundProof [UPPER BOUND(ID), 83 ms]
        (320) CpxRNTS
        (321) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (322) CpxRNTS
        (323) IntTrsBoundProof [UPPER BOUND(ID), 95 ms]
        (324) CpxRNTS
        (325) IntTrsBoundProof [UPPER BOUND(ID), 22 ms]
        (326) CpxRNTS
        (327) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (328) CpxRNTS
        (329) IntTrsBoundProof [UPPER BOUND(ID), 8023 ms]
        (330) CpxRNTS
        (331) IntTrsBoundProof [UPPER BOUND(ID), 2169 ms]
        (332) CpxRNTS
    (333) CompletionProof [UPPER BOUND(ID), 0 ms]
    (334) CpxTypedWeightedCompleteTrs
        (335) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (336) CpxRNTS


----------------------------------------

(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) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT
----------------------------------------

(4)
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


----------------------------------------

(5) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID))
Converted S to standard rules, and D \ S as well as R to relative rules.
----------------------------------------

(6)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, INF).


The TRS R consists of the following rules:

   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

The (relative) TRS S consists of the following 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

Rewrite Strategy: INNERMOST
----------------------------------------

(7) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

(8)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, INF).


The TRS R consists of the following rules:

   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

The (relative) TRS S consists of the following 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

Rewrite Strategy: INNERMOST
----------------------------------------

(9) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Inferred types.
----------------------------------------

(10)
Obligation:
Innermost TRS:
Rules:
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
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

Types:
PROD :: nil:cons -> c1
c1 :: c2 -> c1
PRODITER :: nil:cons -> 0':s:error -> c2
s :: 0':s:error -> 0':s:error
0' :: 0':s:error
c2 :: c3:c4:c5 -> c12:c13 -> c2
IFPROD :: true:false -> nil:cons -> 0':s:error -> c3:c4:c5
isempty :: nil:cons -> true:false
ISEMPTY :: nil:cons -> c12:c13
true :: true:false
c3 :: c3:c4:c5
false :: true:false
c4 :: c2 -> c16:c17 -> c3:c4:c5
tail :: nil:cons -> nil:cons
times :: 0':s:error -> 0':s:error -> 0':s:error
head :: nil:cons -> 0':s:error
TAIL :: nil:cons -> c16:c17
c5 :: c2 -> c8 -> c14:c15 -> c3:c4:c5
TIMES :: 0':s:error -> 0':s:error -> c8
HEAD :: nil:cons -> c14:c15
PLUS :: 0':s:error -> 0':s:error -> c6:c7
c6 :: c6:c7
c7 :: c6:c7 -> c6:c7
c8 :: c9 -> c8
TIMESITER :: 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c9
c9 :: c10:c11 -> c18:c19:c20 -> c9
IFTIMES :: true:false -> 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c10:c11
ge :: 0':s:error -> 0':s:error -> true:false
GE :: 0':s:error -> 0':s:error -> c18:c19:c20
c10 :: c10:c11
c11 :: c9 -> c6:c7 -> c10:c11
plus :: 0':s:error -> 0':s:error -> 0':s:error
nil :: nil:cons
c12 :: c12:c13
cons :: 0':s:error -> nil:cons -> nil:cons
c13 :: c12:c13
c14 :: c14:c15
c15 :: c14:c15
c16 :: c16:c17
c17 :: c16:c17
c18 :: c18:c19:c20
c19 :: c18:c19:c20
c20 :: c18:c19:c20 -> c18:c19:c20
A :: c21:c22
c21 :: c21:c22
c22 :: c21:c22
prod :: nil:cons -> 0':s:error
prodIter :: nil:cons -> 0':s:error -> 0':s:error
ifProd :: true:false -> nil:cons -> 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
error :: 0':s:error
a :: b:c
b :: b:c
c :: b:c
hole_c11_23 :: c1
hole_nil:cons2_23 :: nil:cons
hole_c23_23 :: c2
hole_0':s:error4_23 :: 0':s:error
hole_c3:c4:c55_23 :: c3:c4:c5
hole_c12:c136_23 :: c12:c13
hole_true:false7_23 :: true:false
hole_c16:c178_23 :: c16:c17
hole_c89_23 :: c8
hole_c14:c1510_23 :: c14:c15
hole_c6:c711_23 :: c6:c7
hole_c912_23 :: c9
hole_c10:c1113_23 :: c10:c11
hole_c18:c19:c2014_23 :: c18:c19:c20
hole_c21:c2215_23 :: c21:c22
hole_b:c16_23 :: b:c
gen_nil:cons17_23 :: Nat -> nil:cons
gen_0':s:error18_23 :: Nat -> 0':s:error
gen_c6:c719_23 :: Nat -> c6:c7
gen_c18:c19:c2020_23 :: Nat -> c18:c19:c20

----------------------------------------

(11) OrderProof (LOWER BOUND(ID))
Heuristically decided to analyse the following defined symbols:
PRODITER, PLUS, TIMESITER, ge, GE, plus, prodIter, timesIter

They will be analysed ascendingly in the following order:
PLUS < TIMESITER
ge < TIMESITER
GE < TIMESITER
plus < TIMESITER
ge < timesIter
plus < timesIter

----------------------------------------

(12)
Obligation:
Innermost TRS:
Rules:
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
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

Types:
PROD :: nil:cons -> c1
c1 :: c2 -> c1
PRODITER :: nil:cons -> 0':s:error -> c2
s :: 0':s:error -> 0':s:error
0' :: 0':s:error
c2 :: c3:c4:c5 -> c12:c13 -> c2
IFPROD :: true:false -> nil:cons -> 0':s:error -> c3:c4:c5
isempty :: nil:cons -> true:false
ISEMPTY :: nil:cons -> c12:c13
true :: true:false
c3 :: c3:c4:c5
false :: true:false
c4 :: c2 -> c16:c17 -> c3:c4:c5
tail :: nil:cons -> nil:cons
times :: 0':s:error -> 0':s:error -> 0':s:error
head :: nil:cons -> 0':s:error
TAIL :: nil:cons -> c16:c17
c5 :: c2 -> c8 -> c14:c15 -> c3:c4:c5
TIMES :: 0':s:error -> 0':s:error -> c8
HEAD :: nil:cons -> c14:c15
PLUS :: 0':s:error -> 0':s:error -> c6:c7
c6 :: c6:c7
c7 :: c6:c7 -> c6:c7
c8 :: c9 -> c8
TIMESITER :: 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c9
c9 :: c10:c11 -> c18:c19:c20 -> c9
IFTIMES :: true:false -> 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c10:c11
ge :: 0':s:error -> 0':s:error -> true:false
GE :: 0':s:error -> 0':s:error -> c18:c19:c20
c10 :: c10:c11
c11 :: c9 -> c6:c7 -> c10:c11
plus :: 0':s:error -> 0':s:error -> 0':s:error
nil :: nil:cons
c12 :: c12:c13
cons :: 0':s:error -> nil:cons -> nil:cons
c13 :: c12:c13
c14 :: c14:c15
c15 :: c14:c15
c16 :: c16:c17
c17 :: c16:c17
c18 :: c18:c19:c20
c19 :: c18:c19:c20
c20 :: c18:c19:c20 -> c18:c19:c20
A :: c21:c22
c21 :: c21:c22
c22 :: c21:c22
prod :: nil:cons -> 0':s:error
prodIter :: nil:cons -> 0':s:error -> 0':s:error
ifProd :: true:false -> nil:cons -> 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
error :: 0':s:error
a :: b:c
b :: b:c
c :: b:c
hole_c11_23 :: c1
hole_nil:cons2_23 :: nil:cons
hole_c23_23 :: c2
hole_0':s:error4_23 :: 0':s:error
hole_c3:c4:c55_23 :: c3:c4:c5
hole_c12:c136_23 :: c12:c13
hole_true:false7_23 :: true:false
hole_c16:c178_23 :: c16:c17
hole_c89_23 :: c8
hole_c14:c1510_23 :: c14:c15
hole_c6:c711_23 :: c6:c7
hole_c912_23 :: c9
hole_c10:c1113_23 :: c10:c11
hole_c18:c19:c2014_23 :: c18:c19:c20
hole_c21:c2215_23 :: c21:c22
hole_b:c16_23 :: b:c
gen_nil:cons17_23 :: Nat -> nil:cons
gen_0':s:error18_23 :: Nat -> 0':s:error
gen_c6:c719_23 :: Nat -> c6:c7
gen_c18:c19:c2020_23 :: Nat -> c18:c19:c20


Generator Equations:
gen_nil:cons17_23(0) <=> nil
gen_nil:cons17_23(+(x, 1)) <=> cons(0', gen_nil:cons17_23(x))
gen_0':s:error18_23(0) <=> 0'
gen_0':s:error18_23(+(x, 1)) <=> s(gen_0':s:error18_23(x))
gen_c6:c719_23(0) <=> c6
gen_c6:c719_23(+(x, 1)) <=> c7(gen_c6:c719_23(x))
gen_c18:c19:c2020_23(0) <=> c18
gen_c18:c19:c2020_23(+(x, 1)) <=> c20(gen_c18:c19:c2020_23(x))


The following defined symbols remain to be analysed:
PRODITER, PLUS, TIMESITER, ge, GE, plus, prodIter, timesIter

They will be analysed ascendingly in the following order:
PLUS < TIMESITER
ge < TIMESITER
GE < TIMESITER
plus < TIMESITER
ge < timesIter
plus < timesIter

----------------------------------------

(13) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
PRODITER(gen_nil:cons17_23(n22_23), gen_0':s:error18_23(0)) -> *21_23, rt in Omega(n22_23)

Induction Base:
PRODITER(gen_nil:cons17_23(0), gen_0':s:error18_23(0))

Induction Step:
PRODITER(gen_nil:cons17_23(+(n22_23, 1)), gen_0':s:error18_23(0)) ->_R^Omega(1)
c2(IFPROD(isempty(gen_nil:cons17_23(+(n22_23, 1))), gen_nil:cons17_23(+(n22_23, 1)), gen_0':s:error18_23(0)), ISEMPTY(gen_nil:cons17_23(+(n22_23, 1)))) ->_R^Omega(0)
c2(IFPROD(false, gen_nil:cons17_23(+(1, n22_23)), gen_0':s:error18_23(0)), ISEMPTY(gen_nil:cons17_23(+(1, n22_23)))) ->_R^Omega(1)
c2(c4(PRODITER(tail(gen_nil:cons17_23(+(1, n22_23))), times(gen_0':s:error18_23(0), head(gen_nil:cons17_23(+(1, n22_23))))), TAIL(gen_nil:cons17_23(+(1, n22_23)))), ISEMPTY(gen_nil:cons17_23(+(1, n22_23)))) ->_R^Omega(0)
c2(c4(PRODITER(gen_nil:cons17_23(n22_23), times(gen_0':s:error18_23(0), head(gen_nil:cons17_23(+(1, n22_23))))), TAIL(gen_nil:cons17_23(+(1, n22_23)))), ISEMPTY(gen_nil:cons17_23(+(1, n22_23)))) ->_R^Omega(0)
c2(c4(PRODITER(gen_nil:cons17_23(n22_23), times(gen_0':s:error18_23(0), 0')), TAIL(gen_nil:cons17_23(+(1, n22_23)))), ISEMPTY(gen_nil:cons17_23(+(1, n22_23)))) ->_R^Omega(0)
c2(c4(PRODITER(gen_nil:cons17_23(n22_23), timesIter(gen_0':s:error18_23(0), 0', 0', 0')), TAIL(gen_nil:cons17_23(+(1, n22_23)))), ISEMPTY(gen_nil:cons17_23(+(1, n22_23)))) ->_R^Omega(0)
c2(c4(PRODITER(gen_nil:cons17_23(n22_23), ifTimes(ge(0', gen_0':s:error18_23(0)), gen_0':s:error18_23(0), 0', 0', 0')), TAIL(gen_nil:cons17_23(+(1, n22_23)))), ISEMPTY(gen_nil:cons17_23(+(1, n22_23)))) ->_R^Omega(0)
c2(c4(PRODITER(gen_nil:cons17_23(n22_23), ifTimes(true, gen_0':s:error18_23(0), 0', 0', 0')), TAIL(gen_nil:cons17_23(+(1, n22_23)))), ISEMPTY(gen_nil:cons17_23(+(1, n22_23)))) ->_R^Omega(0)
c2(c4(PRODITER(gen_nil:cons17_23(n22_23), 0'), TAIL(gen_nil:cons17_23(+(1, n22_23)))), ISEMPTY(gen_nil:cons17_23(+(1, n22_23)))) ->_IH
c2(c4(*21_23, TAIL(gen_nil:cons17_23(+(1, n22_23)))), ISEMPTY(gen_nil:cons17_23(+(1, n22_23)))) ->_R^Omega(1)
c2(c4(*21_23, c17), ISEMPTY(gen_nil:cons17_23(+(1, n22_23)))) ->_R^Omega(1)
c2(c4(*21_23, c17), c13)

We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n).
----------------------------------------

(14)
Complex Obligation (BEST)

----------------------------------------

(15)
Obligation:
Proved the lower bound n^1 for the following obligation:

Innermost TRS:
Rules:
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
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

Types:
PROD :: nil:cons -> c1
c1 :: c2 -> c1
PRODITER :: nil:cons -> 0':s:error -> c2
s :: 0':s:error -> 0':s:error
0' :: 0':s:error
c2 :: c3:c4:c5 -> c12:c13 -> c2
IFPROD :: true:false -> nil:cons -> 0':s:error -> c3:c4:c5
isempty :: nil:cons -> true:false
ISEMPTY :: nil:cons -> c12:c13
true :: true:false
c3 :: c3:c4:c5
false :: true:false
c4 :: c2 -> c16:c17 -> c3:c4:c5
tail :: nil:cons -> nil:cons
times :: 0':s:error -> 0':s:error -> 0':s:error
head :: nil:cons -> 0':s:error
TAIL :: nil:cons -> c16:c17
c5 :: c2 -> c8 -> c14:c15 -> c3:c4:c5
TIMES :: 0':s:error -> 0':s:error -> c8
HEAD :: nil:cons -> c14:c15
PLUS :: 0':s:error -> 0':s:error -> c6:c7
c6 :: c6:c7
c7 :: c6:c7 -> c6:c7
c8 :: c9 -> c8
TIMESITER :: 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c9
c9 :: c10:c11 -> c18:c19:c20 -> c9
IFTIMES :: true:false -> 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c10:c11
ge :: 0':s:error -> 0':s:error -> true:false
GE :: 0':s:error -> 0':s:error -> c18:c19:c20
c10 :: c10:c11
c11 :: c9 -> c6:c7 -> c10:c11
plus :: 0':s:error -> 0':s:error -> 0':s:error
nil :: nil:cons
c12 :: c12:c13
cons :: 0':s:error -> nil:cons -> nil:cons
c13 :: c12:c13
c14 :: c14:c15
c15 :: c14:c15
c16 :: c16:c17
c17 :: c16:c17
c18 :: c18:c19:c20
c19 :: c18:c19:c20
c20 :: c18:c19:c20 -> c18:c19:c20
A :: c21:c22
c21 :: c21:c22
c22 :: c21:c22
prod :: nil:cons -> 0':s:error
prodIter :: nil:cons -> 0':s:error -> 0':s:error
ifProd :: true:false -> nil:cons -> 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
error :: 0':s:error
a :: b:c
b :: b:c
c :: b:c
hole_c11_23 :: c1
hole_nil:cons2_23 :: nil:cons
hole_c23_23 :: c2
hole_0':s:error4_23 :: 0':s:error
hole_c3:c4:c55_23 :: c3:c4:c5
hole_c12:c136_23 :: c12:c13
hole_true:false7_23 :: true:false
hole_c16:c178_23 :: c16:c17
hole_c89_23 :: c8
hole_c14:c1510_23 :: c14:c15
hole_c6:c711_23 :: c6:c7
hole_c912_23 :: c9
hole_c10:c1113_23 :: c10:c11
hole_c18:c19:c2014_23 :: c18:c19:c20
hole_c21:c2215_23 :: c21:c22
hole_b:c16_23 :: b:c
gen_nil:cons17_23 :: Nat -> nil:cons
gen_0':s:error18_23 :: Nat -> 0':s:error
gen_c6:c719_23 :: Nat -> c6:c7
gen_c18:c19:c2020_23 :: Nat -> c18:c19:c20


Generator Equations:
gen_nil:cons17_23(0) <=> nil
gen_nil:cons17_23(+(x, 1)) <=> cons(0', gen_nil:cons17_23(x))
gen_0':s:error18_23(0) <=> 0'
gen_0':s:error18_23(+(x, 1)) <=> s(gen_0':s:error18_23(x))
gen_c6:c719_23(0) <=> c6
gen_c6:c719_23(+(x, 1)) <=> c7(gen_c6:c719_23(x))
gen_c18:c19:c2020_23(0) <=> c18
gen_c18:c19:c2020_23(+(x, 1)) <=> c20(gen_c18:c19:c2020_23(x))


The following defined symbols remain to be analysed:
PRODITER, PLUS, TIMESITER, ge, GE, plus, prodIter, timesIter

They will be analysed ascendingly in the following order:
PLUS < TIMESITER
ge < TIMESITER
GE < TIMESITER
plus < TIMESITER
ge < timesIter
plus < timesIter

----------------------------------------

(16) LowerBoundPropagationProof (FINISHED)
Propagated lower bound.
----------------------------------------

(17)
BOUNDS(n^1, INF)

----------------------------------------

(18)
Obligation:
Innermost TRS:
Rules:
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
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

Types:
PROD :: nil:cons -> c1
c1 :: c2 -> c1
PRODITER :: nil:cons -> 0':s:error -> c2
s :: 0':s:error -> 0':s:error
0' :: 0':s:error
c2 :: c3:c4:c5 -> c12:c13 -> c2
IFPROD :: true:false -> nil:cons -> 0':s:error -> c3:c4:c5
isempty :: nil:cons -> true:false
ISEMPTY :: nil:cons -> c12:c13
true :: true:false
c3 :: c3:c4:c5
false :: true:false
c4 :: c2 -> c16:c17 -> c3:c4:c5
tail :: nil:cons -> nil:cons
times :: 0':s:error -> 0':s:error -> 0':s:error
head :: nil:cons -> 0':s:error
TAIL :: nil:cons -> c16:c17
c5 :: c2 -> c8 -> c14:c15 -> c3:c4:c5
TIMES :: 0':s:error -> 0':s:error -> c8
HEAD :: nil:cons -> c14:c15
PLUS :: 0':s:error -> 0':s:error -> c6:c7
c6 :: c6:c7
c7 :: c6:c7 -> c6:c7
c8 :: c9 -> c8
TIMESITER :: 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c9
c9 :: c10:c11 -> c18:c19:c20 -> c9
IFTIMES :: true:false -> 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c10:c11
ge :: 0':s:error -> 0':s:error -> true:false
GE :: 0':s:error -> 0':s:error -> c18:c19:c20
c10 :: c10:c11
c11 :: c9 -> c6:c7 -> c10:c11
plus :: 0':s:error -> 0':s:error -> 0':s:error
nil :: nil:cons
c12 :: c12:c13
cons :: 0':s:error -> nil:cons -> nil:cons
c13 :: c12:c13
c14 :: c14:c15
c15 :: c14:c15
c16 :: c16:c17
c17 :: c16:c17
c18 :: c18:c19:c20
c19 :: c18:c19:c20
c20 :: c18:c19:c20 -> c18:c19:c20
A :: c21:c22
c21 :: c21:c22
c22 :: c21:c22
prod :: nil:cons -> 0':s:error
prodIter :: nil:cons -> 0':s:error -> 0':s:error
ifProd :: true:false -> nil:cons -> 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
error :: 0':s:error
a :: b:c
b :: b:c
c :: b:c
hole_c11_23 :: c1
hole_nil:cons2_23 :: nil:cons
hole_c23_23 :: c2
hole_0':s:error4_23 :: 0':s:error
hole_c3:c4:c55_23 :: c3:c4:c5
hole_c12:c136_23 :: c12:c13
hole_true:false7_23 :: true:false
hole_c16:c178_23 :: c16:c17
hole_c89_23 :: c8
hole_c14:c1510_23 :: c14:c15
hole_c6:c711_23 :: c6:c7
hole_c912_23 :: c9
hole_c10:c1113_23 :: c10:c11
hole_c18:c19:c2014_23 :: c18:c19:c20
hole_c21:c2215_23 :: c21:c22
hole_b:c16_23 :: b:c
gen_nil:cons17_23 :: Nat -> nil:cons
gen_0':s:error18_23 :: Nat -> 0':s:error
gen_c6:c719_23 :: Nat -> c6:c7
gen_c18:c19:c2020_23 :: Nat -> c18:c19:c20


Lemmas:
PRODITER(gen_nil:cons17_23(n22_23), gen_0':s:error18_23(0)) -> *21_23, rt in Omega(n22_23)


Generator Equations:
gen_nil:cons17_23(0) <=> nil
gen_nil:cons17_23(+(x, 1)) <=> cons(0', gen_nil:cons17_23(x))
gen_0':s:error18_23(0) <=> 0'
gen_0':s:error18_23(+(x, 1)) <=> s(gen_0':s:error18_23(x))
gen_c6:c719_23(0) <=> c6
gen_c6:c719_23(+(x, 1)) <=> c7(gen_c6:c719_23(x))
gen_c18:c19:c2020_23(0) <=> c18
gen_c18:c19:c2020_23(+(x, 1)) <=> c20(gen_c18:c19:c2020_23(x))


The following defined symbols remain to be analysed:
PLUS, TIMESITER, ge, GE, plus, prodIter, timesIter

They will be analysed ascendingly in the following order:
PLUS < TIMESITER
ge < TIMESITER
GE < TIMESITER
plus < TIMESITER
ge < timesIter
plus < timesIter

----------------------------------------

(19) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
PLUS(gen_0':s:error18_23(n7606_23), gen_0':s:error18_23(b)) -> gen_c6:c719_23(n7606_23), rt in Omega(1 + n7606_23)

Induction Base:
PLUS(gen_0':s:error18_23(0), gen_0':s:error18_23(b)) ->_R^Omega(1)
c6

Induction Step:
PLUS(gen_0':s:error18_23(+(n7606_23, 1)), gen_0':s:error18_23(b)) ->_R^Omega(1)
c7(PLUS(gen_0':s:error18_23(n7606_23), gen_0':s:error18_23(b))) ->_IH
c7(gen_c6:c719_23(c7607_23))

We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n).
----------------------------------------

(20)
Obligation:
Innermost TRS:
Rules:
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
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

Types:
PROD :: nil:cons -> c1
c1 :: c2 -> c1
PRODITER :: nil:cons -> 0':s:error -> c2
s :: 0':s:error -> 0':s:error
0' :: 0':s:error
c2 :: c3:c4:c5 -> c12:c13 -> c2
IFPROD :: true:false -> nil:cons -> 0':s:error -> c3:c4:c5
isempty :: nil:cons -> true:false
ISEMPTY :: nil:cons -> c12:c13
true :: true:false
c3 :: c3:c4:c5
false :: true:false
c4 :: c2 -> c16:c17 -> c3:c4:c5
tail :: nil:cons -> nil:cons
times :: 0':s:error -> 0':s:error -> 0':s:error
head :: nil:cons -> 0':s:error
TAIL :: nil:cons -> c16:c17
c5 :: c2 -> c8 -> c14:c15 -> c3:c4:c5
TIMES :: 0':s:error -> 0':s:error -> c8
HEAD :: nil:cons -> c14:c15
PLUS :: 0':s:error -> 0':s:error -> c6:c7
c6 :: c6:c7
c7 :: c6:c7 -> c6:c7
c8 :: c9 -> c8
TIMESITER :: 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c9
c9 :: c10:c11 -> c18:c19:c20 -> c9
IFTIMES :: true:false -> 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c10:c11
ge :: 0':s:error -> 0':s:error -> true:false
GE :: 0':s:error -> 0':s:error -> c18:c19:c20
c10 :: c10:c11
c11 :: c9 -> c6:c7 -> c10:c11
plus :: 0':s:error -> 0':s:error -> 0':s:error
nil :: nil:cons
c12 :: c12:c13
cons :: 0':s:error -> nil:cons -> nil:cons
c13 :: c12:c13
c14 :: c14:c15
c15 :: c14:c15
c16 :: c16:c17
c17 :: c16:c17
c18 :: c18:c19:c20
c19 :: c18:c19:c20
c20 :: c18:c19:c20 -> c18:c19:c20
A :: c21:c22
c21 :: c21:c22
c22 :: c21:c22
prod :: nil:cons -> 0':s:error
prodIter :: nil:cons -> 0':s:error -> 0':s:error
ifProd :: true:false -> nil:cons -> 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
error :: 0':s:error
a :: b:c
b :: b:c
c :: b:c
hole_c11_23 :: c1
hole_nil:cons2_23 :: nil:cons
hole_c23_23 :: c2
hole_0':s:error4_23 :: 0':s:error
hole_c3:c4:c55_23 :: c3:c4:c5
hole_c12:c136_23 :: c12:c13
hole_true:false7_23 :: true:false
hole_c16:c178_23 :: c16:c17
hole_c89_23 :: c8
hole_c14:c1510_23 :: c14:c15
hole_c6:c711_23 :: c6:c7
hole_c912_23 :: c9
hole_c10:c1113_23 :: c10:c11
hole_c18:c19:c2014_23 :: c18:c19:c20
hole_c21:c2215_23 :: c21:c22
hole_b:c16_23 :: b:c
gen_nil:cons17_23 :: Nat -> nil:cons
gen_0':s:error18_23 :: Nat -> 0':s:error
gen_c6:c719_23 :: Nat -> c6:c7
gen_c18:c19:c2020_23 :: Nat -> c18:c19:c20


Lemmas:
PRODITER(gen_nil:cons17_23(n22_23), gen_0':s:error18_23(0)) -> *21_23, rt in Omega(n22_23)
PLUS(gen_0':s:error18_23(n7606_23), gen_0':s:error18_23(b)) -> gen_c6:c719_23(n7606_23), rt in Omega(1 + n7606_23)


Generator Equations:
gen_nil:cons17_23(0) <=> nil
gen_nil:cons17_23(+(x, 1)) <=> cons(0', gen_nil:cons17_23(x))
gen_0':s:error18_23(0) <=> 0'
gen_0':s:error18_23(+(x, 1)) <=> s(gen_0':s:error18_23(x))
gen_c6:c719_23(0) <=> c6
gen_c6:c719_23(+(x, 1)) <=> c7(gen_c6:c719_23(x))
gen_c18:c19:c2020_23(0) <=> c18
gen_c18:c19:c2020_23(+(x, 1)) <=> c20(gen_c18:c19:c2020_23(x))


The following defined symbols remain to be analysed:
ge, TIMESITER, GE, plus, prodIter, timesIter

They will be analysed ascendingly in the following order:
ge < TIMESITER
GE < TIMESITER
plus < TIMESITER
ge < timesIter
plus < timesIter

----------------------------------------

(21) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
ge(gen_0':s:error18_23(n8624_23), gen_0':s:error18_23(n8624_23)) -> true, rt in Omega(0)

Induction Base:
ge(gen_0':s:error18_23(0), gen_0':s:error18_23(0)) ->_R^Omega(0)
true

Induction Step:
ge(gen_0':s:error18_23(+(n8624_23, 1)), gen_0':s:error18_23(+(n8624_23, 1))) ->_R^Omega(0)
ge(gen_0':s:error18_23(n8624_23), gen_0':s:error18_23(n8624_23)) ->_IH
true

We have rt in Omega(1) and sz in O(n). Thus, we have irc_R in Omega(n^0).
----------------------------------------

(22)
Obligation:
Innermost TRS:
Rules:
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
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

Types:
PROD :: nil:cons -> c1
c1 :: c2 -> c1
PRODITER :: nil:cons -> 0':s:error -> c2
s :: 0':s:error -> 0':s:error
0' :: 0':s:error
c2 :: c3:c4:c5 -> c12:c13 -> c2
IFPROD :: true:false -> nil:cons -> 0':s:error -> c3:c4:c5
isempty :: nil:cons -> true:false
ISEMPTY :: nil:cons -> c12:c13
true :: true:false
c3 :: c3:c4:c5
false :: true:false
c4 :: c2 -> c16:c17 -> c3:c4:c5
tail :: nil:cons -> nil:cons
times :: 0':s:error -> 0':s:error -> 0':s:error
head :: nil:cons -> 0':s:error
TAIL :: nil:cons -> c16:c17
c5 :: c2 -> c8 -> c14:c15 -> c3:c4:c5
TIMES :: 0':s:error -> 0':s:error -> c8
HEAD :: nil:cons -> c14:c15
PLUS :: 0':s:error -> 0':s:error -> c6:c7
c6 :: c6:c7
c7 :: c6:c7 -> c6:c7
c8 :: c9 -> c8
TIMESITER :: 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c9
c9 :: c10:c11 -> c18:c19:c20 -> c9
IFTIMES :: true:false -> 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c10:c11
ge :: 0':s:error -> 0':s:error -> true:false
GE :: 0':s:error -> 0':s:error -> c18:c19:c20
c10 :: c10:c11
c11 :: c9 -> c6:c7 -> c10:c11
plus :: 0':s:error -> 0':s:error -> 0':s:error
nil :: nil:cons
c12 :: c12:c13
cons :: 0':s:error -> nil:cons -> nil:cons
c13 :: c12:c13
c14 :: c14:c15
c15 :: c14:c15
c16 :: c16:c17
c17 :: c16:c17
c18 :: c18:c19:c20
c19 :: c18:c19:c20
c20 :: c18:c19:c20 -> c18:c19:c20
A :: c21:c22
c21 :: c21:c22
c22 :: c21:c22
prod :: nil:cons -> 0':s:error
prodIter :: nil:cons -> 0':s:error -> 0':s:error
ifProd :: true:false -> nil:cons -> 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
error :: 0':s:error
a :: b:c
b :: b:c
c :: b:c
hole_c11_23 :: c1
hole_nil:cons2_23 :: nil:cons
hole_c23_23 :: c2
hole_0':s:error4_23 :: 0':s:error
hole_c3:c4:c55_23 :: c3:c4:c5
hole_c12:c136_23 :: c12:c13
hole_true:false7_23 :: true:false
hole_c16:c178_23 :: c16:c17
hole_c89_23 :: c8
hole_c14:c1510_23 :: c14:c15
hole_c6:c711_23 :: c6:c7
hole_c912_23 :: c9
hole_c10:c1113_23 :: c10:c11
hole_c18:c19:c2014_23 :: c18:c19:c20
hole_c21:c2215_23 :: c21:c22
hole_b:c16_23 :: b:c
gen_nil:cons17_23 :: Nat -> nil:cons
gen_0':s:error18_23 :: Nat -> 0':s:error
gen_c6:c719_23 :: Nat -> c6:c7
gen_c18:c19:c2020_23 :: Nat -> c18:c19:c20


Lemmas:
PRODITER(gen_nil:cons17_23(n22_23), gen_0':s:error18_23(0)) -> *21_23, rt in Omega(n22_23)
PLUS(gen_0':s:error18_23(n7606_23), gen_0':s:error18_23(b)) -> gen_c6:c719_23(n7606_23), rt in Omega(1 + n7606_23)
ge(gen_0':s:error18_23(n8624_23), gen_0':s:error18_23(n8624_23)) -> true, rt in Omega(0)


Generator Equations:
gen_nil:cons17_23(0) <=> nil
gen_nil:cons17_23(+(x, 1)) <=> cons(0', gen_nil:cons17_23(x))
gen_0':s:error18_23(0) <=> 0'
gen_0':s:error18_23(+(x, 1)) <=> s(gen_0':s:error18_23(x))
gen_c6:c719_23(0) <=> c6
gen_c6:c719_23(+(x, 1)) <=> c7(gen_c6:c719_23(x))
gen_c18:c19:c2020_23(0) <=> c18
gen_c18:c19:c2020_23(+(x, 1)) <=> c20(gen_c18:c19:c2020_23(x))


The following defined symbols remain to be analysed:
GE, TIMESITER, plus, prodIter, timesIter

They will be analysed ascendingly in the following order:
GE < TIMESITER
plus < TIMESITER
plus < timesIter

----------------------------------------

(23) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
GE(gen_0':s:error18_23(n9216_23), gen_0':s:error18_23(n9216_23)) -> gen_c18:c19:c2020_23(n9216_23), rt in Omega(1 + n9216_23)

Induction Base:
GE(gen_0':s:error18_23(0), gen_0':s:error18_23(0)) ->_R^Omega(1)
c18

Induction Step:
GE(gen_0':s:error18_23(+(n9216_23, 1)), gen_0':s:error18_23(+(n9216_23, 1))) ->_R^Omega(1)
c20(GE(gen_0':s:error18_23(n9216_23), gen_0':s:error18_23(n9216_23))) ->_IH
c20(gen_c18:c19:c2020_23(c9217_23))

We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n).
----------------------------------------

(24)
Obligation:
Innermost TRS:
Rules:
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
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

Types:
PROD :: nil:cons -> c1
c1 :: c2 -> c1
PRODITER :: nil:cons -> 0':s:error -> c2
s :: 0':s:error -> 0':s:error
0' :: 0':s:error
c2 :: c3:c4:c5 -> c12:c13 -> c2
IFPROD :: true:false -> nil:cons -> 0':s:error -> c3:c4:c5
isempty :: nil:cons -> true:false
ISEMPTY :: nil:cons -> c12:c13
true :: true:false
c3 :: c3:c4:c5
false :: true:false
c4 :: c2 -> c16:c17 -> c3:c4:c5
tail :: nil:cons -> nil:cons
times :: 0':s:error -> 0':s:error -> 0':s:error
head :: nil:cons -> 0':s:error
TAIL :: nil:cons -> c16:c17
c5 :: c2 -> c8 -> c14:c15 -> c3:c4:c5
TIMES :: 0':s:error -> 0':s:error -> c8
HEAD :: nil:cons -> c14:c15
PLUS :: 0':s:error -> 0':s:error -> c6:c7
c6 :: c6:c7
c7 :: c6:c7 -> c6:c7
c8 :: c9 -> c8
TIMESITER :: 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c9
c9 :: c10:c11 -> c18:c19:c20 -> c9
IFTIMES :: true:false -> 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c10:c11
ge :: 0':s:error -> 0':s:error -> true:false
GE :: 0':s:error -> 0':s:error -> c18:c19:c20
c10 :: c10:c11
c11 :: c9 -> c6:c7 -> c10:c11
plus :: 0':s:error -> 0':s:error -> 0':s:error
nil :: nil:cons
c12 :: c12:c13
cons :: 0':s:error -> nil:cons -> nil:cons
c13 :: c12:c13
c14 :: c14:c15
c15 :: c14:c15
c16 :: c16:c17
c17 :: c16:c17
c18 :: c18:c19:c20
c19 :: c18:c19:c20
c20 :: c18:c19:c20 -> c18:c19:c20
A :: c21:c22
c21 :: c21:c22
c22 :: c21:c22
prod :: nil:cons -> 0':s:error
prodIter :: nil:cons -> 0':s:error -> 0':s:error
ifProd :: true:false -> nil:cons -> 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
error :: 0':s:error
a :: b:c
b :: b:c
c :: b:c
hole_c11_23 :: c1
hole_nil:cons2_23 :: nil:cons
hole_c23_23 :: c2
hole_0':s:error4_23 :: 0':s:error
hole_c3:c4:c55_23 :: c3:c4:c5
hole_c12:c136_23 :: c12:c13
hole_true:false7_23 :: true:false
hole_c16:c178_23 :: c16:c17
hole_c89_23 :: c8
hole_c14:c1510_23 :: c14:c15
hole_c6:c711_23 :: c6:c7
hole_c912_23 :: c9
hole_c10:c1113_23 :: c10:c11
hole_c18:c19:c2014_23 :: c18:c19:c20
hole_c21:c2215_23 :: c21:c22
hole_b:c16_23 :: b:c
gen_nil:cons17_23 :: Nat -> nil:cons
gen_0':s:error18_23 :: Nat -> 0':s:error
gen_c6:c719_23 :: Nat -> c6:c7
gen_c18:c19:c2020_23 :: Nat -> c18:c19:c20


Lemmas:
PRODITER(gen_nil:cons17_23(n22_23), gen_0':s:error18_23(0)) -> *21_23, rt in Omega(n22_23)
PLUS(gen_0':s:error18_23(n7606_23), gen_0':s:error18_23(b)) -> gen_c6:c719_23(n7606_23), rt in Omega(1 + n7606_23)
ge(gen_0':s:error18_23(n8624_23), gen_0':s:error18_23(n8624_23)) -> true, rt in Omega(0)
GE(gen_0':s:error18_23(n9216_23), gen_0':s:error18_23(n9216_23)) -> gen_c18:c19:c2020_23(n9216_23), rt in Omega(1 + n9216_23)


Generator Equations:
gen_nil:cons17_23(0) <=> nil
gen_nil:cons17_23(+(x, 1)) <=> cons(0', gen_nil:cons17_23(x))
gen_0':s:error18_23(0) <=> 0'
gen_0':s:error18_23(+(x, 1)) <=> s(gen_0':s:error18_23(x))
gen_c6:c719_23(0) <=> c6
gen_c6:c719_23(+(x, 1)) <=> c7(gen_c6:c719_23(x))
gen_c18:c19:c2020_23(0) <=> c18
gen_c18:c19:c2020_23(+(x, 1)) <=> c20(gen_c18:c19:c2020_23(x))


The following defined symbols remain to be analysed:
plus, TIMESITER, prodIter, timesIter

They will be analysed ascendingly in the following order:
plus < TIMESITER
plus < timesIter

----------------------------------------

(25) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
plus(gen_0':s:error18_23(n10225_23), gen_0':s:error18_23(b)) -> gen_0':s:error18_23(+(n10225_23, b)), rt in Omega(0)

Induction Base:
plus(gen_0':s:error18_23(0), gen_0':s:error18_23(b)) ->_R^Omega(0)
gen_0':s:error18_23(b)

Induction Step:
plus(gen_0':s:error18_23(+(n10225_23, 1)), gen_0':s:error18_23(b)) ->_R^Omega(0)
s(plus(gen_0':s:error18_23(n10225_23), gen_0':s:error18_23(b))) ->_IH
s(gen_0':s:error18_23(+(b, c10226_23)))

We have rt in Omega(1) and sz in O(n). Thus, we have irc_R in Omega(n^0).
----------------------------------------

(26)
Obligation:
Innermost TRS:
Rules:
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
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

Types:
PROD :: nil:cons -> c1
c1 :: c2 -> c1
PRODITER :: nil:cons -> 0':s:error -> c2
s :: 0':s:error -> 0':s:error
0' :: 0':s:error
c2 :: c3:c4:c5 -> c12:c13 -> c2
IFPROD :: true:false -> nil:cons -> 0':s:error -> c3:c4:c5
isempty :: nil:cons -> true:false
ISEMPTY :: nil:cons -> c12:c13
true :: true:false
c3 :: c3:c4:c5
false :: true:false
c4 :: c2 -> c16:c17 -> c3:c4:c5
tail :: nil:cons -> nil:cons
times :: 0':s:error -> 0':s:error -> 0':s:error
head :: nil:cons -> 0':s:error
TAIL :: nil:cons -> c16:c17
c5 :: c2 -> c8 -> c14:c15 -> c3:c4:c5
TIMES :: 0':s:error -> 0':s:error -> c8
HEAD :: nil:cons -> c14:c15
PLUS :: 0':s:error -> 0':s:error -> c6:c7
c6 :: c6:c7
c7 :: c6:c7 -> c6:c7
c8 :: c9 -> c8
TIMESITER :: 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c9
c9 :: c10:c11 -> c18:c19:c20 -> c9
IFTIMES :: true:false -> 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c10:c11
ge :: 0':s:error -> 0':s:error -> true:false
GE :: 0':s:error -> 0':s:error -> c18:c19:c20
c10 :: c10:c11
c11 :: c9 -> c6:c7 -> c10:c11
plus :: 0':s:error -> 0':s:error -> 0':s:error
nil :: nil:cons
c12 :: c12:c13
cons :: 0':s:error -> nil:cons -> nil:cons
c13 :: c12:c13
c14 :: c14:c15
c15 :: c14:c15
c16 :: c16:c17
c17 :: c16:c17
c18 :: c18:c19:c20
c19 :: c18:c19:c20
c20 :: c18:c19:c20 -> c18:c19:c20
A :: c21:c22
c21 :: c21:c22
c22 :: c21:c22
prod :: nil:cons -> 0':s:error
prodIter :: nil:cons -> 0':s:error -> 0':s:error
ifProd :: true:false -> nil:cons -> 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
error :: 0':s:error
a :: b:c
b :: b:c
c :: b:c
hole_c11_23 :: c1
hole_nil:cons2_23 :: nil:cons
hole_c23_23 :: c2
hole_0':s:error4_23 :: 0':s:error
hole_c3:c4:c55_23 :: c3:c4:c5
hole_c12:c136_23 :: c12:c13
hole_true:false7_23 :: true:false
hole_c16:c178_23 :: c16:c17
hole_c89_23 :: c8
hole_c14:c1510_23 :: c14:c15
hole_c6:c711_23 :: c6:c7
hole_c912_23 :: c9
hole_c10:c1113_23 :: c10:c11
hole_c18:c19:c2014_23 :: c18:c19:c20
hole_c21:c2215_23 :: c21:c22
hole_b:c16_23 :: b:c
gen_nil:cons17_23 :: Nat -> nil:cons
gen_0':s:error18_23 :: Nat -> 0':s:error
gen_c6:c719_23 :: Nat -> c6:c7
gen_c18:c19:c2020_23 :: Nat -> c18:c19:c20


Lemmas:
PRODITER(gen_nil:cons17_23(n22_23), gen_0':s:error18_23(0)) -> *21_23, rt in Omega(n22_23)
PLUS(gen_0':s:error18_23(n7606_23), gen_0':s:error18_23(b)) -> gen_c6:c719_23(n7606_23), rt in Omega(1 + n7606_23)
ge(gen_0':s:error18_23(n8624_23), gen_0':s:error18_23(n8624_23)) -> true, rt in Omega(0)
GE(gen_0':s:error18_23(n9216_23), gen_0':s:error18_23(n9216_23)) -> gen_c18:c19:c2020_23(n9216_23), rt in Omega(1 + n9216_23)
plus(gen_0':s:error18_23(n10225_23), gen_0':s:error18_23(b)) -> gen_0':s:error18_23(+(n10225_23, b)), rt in Omega(0)


Generator Equations:
gen_nil:cons17_23(0) <=> nil
gen_nil:cons17_23(+(x, 1)) <=> cons(0', gen_nil:cons17_23(x))
gen_0':s:error18_23(0) <=> 0'
gen_0':s:error18_23(+(x, 1)) <=> s(gen_0':s:error18_23(x))
gen_c6:c719_23(0) <=> c6
gen_c6:c719_23(+(x, 1)) <=> c7(gen_c6:c719_23(x))
gen_c18:c19:c2020_23(0) <=> c18
gen_c18:c19:c2020_23(+(x, 1)) <=> c20(gen_c18:c19:c2020_23(x))


The following defined symbols remain to be analysed:
TIMESITER, prodIter, timesIter
----------------------------------------

(27) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
prodIter(gen_nil:cons17_23(n12379_23), gen_0':s:error18_23(0)) -> gen_0':s:error18_23(0), rt in Omega(0)

Induction Base:
prodIter(gen_nil:cons17_23(0), gen_0':s:error18_23(0)) ->_R^Omega(0)
ifProd(isempty(gen_nil:cons17_23(0)), gen_nil:cons17_23(0), gen_0':s:error18_23(0)) ->_R^Omega(0)
ifProd(true, gen_nil:cons17_23(0), gen_0':s:error18_23(0)) ->_R^Omega(0)
gen_0':s:error18_23(0)

Induction Step:
prodIter(gen_nil:cons17_23(+(n12379_23, 1)), gen_0':s:error18_23(0)) ->_R^Omega(0)
ifProd(isempty(gen_nil:cons17_23(+(n12379_23, 1))), gen_nil:cons17_23(+(n12379_23, 1)), gen_0':s:error18_23(0)) ->_R^Omega(0)
ifProd(false, gen_nil:cons17_23(+(1, n12379_23)), gen_0':s:error18_23(0)) ->_R^Omega(0)
prodIter(tail(gen_nil:cons17_23(+(1, n12379_23))), times(gen_0':s:error18_23(0), head(gen_nil:cons17_23(+(1, n12379_23))))) ->_R^Omega(0)
prodIter(gen_nil:cons17_23(n12379_23), times(gen_0':s:error18_23(0), head(gen_nil:cons17_23(+(1, n12379_23))))) ->_R^Omega(0)
prodIter(gen_nil:cons17_23(n12379_23), times(gen_0':s:error18_23(0), 0')) ->_R^Omega(0)
prodIter(gen_nil:cons17_23(n12379_23), timesIter(gen_0':s:error18_23(0), 0', 0', 0')) ->_R^Omega(0)
prodIter(gen_nil:cons17_23(n12379_23), ifTimes(ge(0', gen_0':s:error18_23(0)), gen_0':s:error18_23(0), 0', 0', 0')) ->_L^Omega(0)
prodIter(gen_nil:cons17_23(n12379_23), ifTimes(true, gen_0':s:error18_23(0), 0', 0', 0')) ->_R^Omega(0)
prodIter(gen_nil:cons17_23(n12379_23), 0') ->_IH
gen_0':s:error18_23(0)

We have rt in Omega(1) and sz in O(n). Thus, we have irc_R in Omega(n^0).
----------------------------------------

(28)
Obligation:
Innermost TRS:
Rules:
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
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

Types:
PROD :: nil:cons -> c1
c1 :: c2 -> c1
PRODITER :: nil:cons -> 0':s:error -> c2
s :: 0':s:error -> 0':s:error
0' :: 0':s:error
c2 :: c3:c4:c5 -> c12:c13 -> c2
IFPROD :: true:false -> nil:cons -> 0':s:error -> c3:c4:c5
isempty :: nil:cons -> true:false
ISEMPTY :: nil:cons -> c12:c13
true :: true:false
c3 :: c3:c4:c5
false :: true:false
c4 :: c2 -> c16:c17 -> c3:c4:c5
tail :: nil:cons -> nil:cons
times :: 0':s:error -> 0':s:error -> 0':s:error
head :: nil:cons -> 0':s:error
TAIL :: nil:cons -> c16:c17
c5 :: c2 -> c8 -> c14:c15 -> c3:c4:c5
TIMES :: 0':s:error -> 0':s:error -> c8
HEAD :: nil:cons -> c14:c15
PLUS :: 0':s:error -> 0':s:error -> c6:c7
c6 :: c6:c7
c7 :: c6:c7 -> c6:c7
c8 :: c9 -> c8
TIMESITER :: 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c9
c9 :: c10:c11 -> c18:c19:c20 -> c9
IFTIMES :: true:false -> 0':s:error -> 0':s:error -> 0':s:error -> 0':s:error -> c10:c11
ge :: 0':s:error -> 0':s:error -> true:false
GE :: 0':s:error -> 0':s:error -> c18:c19:c20
c10 :: c10:c11
c11 :: c9 -> c6:c7 -> c10:c11
plus :: 0':s:error -> 0':s:error -> 0':s:error
nil :: nil:cons
c12 :: c12:c13
cons :: 0':s:error -> nil:cons -> nil:cons
c13 :: c12:c13
c14 :: c14:c15
c15 :: c14:c15
c16 :: c16:c17
c17 :: c16:c17
c18 :: c18:c19:c20
c19 :: c18:c19:c20
c20 :: c18:c19:c20 -> c18:c19:c20
A :: c21:c22
c21 :: c21:c22
c22 :: c21:c22
prod :: nil:cons -> 0':s:error
prodIter :: nil:cons -> 0':s:error -> 0':s:error
ifProd :: true:false -> nil:cons -> 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
error :: 0':s:error
a :: b:c
b :: b:c
c :: b:c
hole_c11_23 :: c1
hole_nil:cons2_23 :: nil:cons
hole_c23_23 :: c2
hole_0':s:error4_23 :: 0':s:error
hole_c3:c4:c55_23 :: c3:c4:c5
hole_c12:c136_23 :: c12:c13
hole_true:false7_23 :: true:false
hole_c16:c178_23 :: c16:c17
hole_c89_23 :: c8
hole_c14:c1510_23 :: c14:c15
hole_c6:c711_23 :: c6:c7
hole_c912_23 :: c9
hole_c10:c1113_23 :: c10:c11
hole_c18:c19:c2014_23 :: c18:c19:c20
hole_c21:c2215_23 :: c21:c22
hole_b:c16_23 :: b:c
gen_nil:cons17_23 :: Nat -> nil:cons
gen_0':s:error18_23 :: Nat -> 0':s:error
gen_c6:c719_23 :: Nat -> c6:c7
gen_c18:c19:c2020_23 :: Nat -> c18:c19:c20


Lemmas:
PRODITER(gen_nil:cons17_23(n22_23), gen_0':s:error18_23(0)) -> *21_23, rt in Omega(n22_23)
PLUS(gen_0':s:error18_23(n7606_23), gen_0':s:error18_23(b)) -> gen_c6:c719_23(n7606_23), rt in Omega(1 + n7606_23)
ge(gen_0':s:error18_23(n8624_23), gen_0':s:error18_23(n8624_23)) -> true, rt in Omega(0)
GE(gen_0':s:error18_23(n9216_23), gen_0':s:error18_23(n9216_23)) -> gen_c18:c19:c2020_23(n9216_23), rt in Omega(1 + n9216_23)
plus(gen_0':s:error18_23(n10225_23), gen_0':s:error18_23(b)) -> gen_0':s:error18_23(+(n10225_23, b)), rt in Omega(0)
prodIter(gen_nil:cons17_23(n12379_23), gen_0':s:error18_23(0)) -> gen_0':s:error18_23(0), rt in Omega(0)


Generator Equations:
gen_nil:cons17_23(0) <=> nil
gen_nil:cons17_23(+(x, 1)) <=> cons(0', gen_nil:cons17_23(x))
gen_0':s:error18_23(0) <=> 0'
gen_0':s:error18_23(+(x, 1)) <=> s(gen_0':s:error18_23(x))
gen_c6:c719_23(0) <=> c6
gen_c6:c719_23(+(x, 1)) <=> c7(gen_c6:c719_23(x))
gen_c18:c19:c2020_23(0) <=> c18
gen_c18:c19:c2020_23(+(x, 1)) <=> c20(gen_c18:c19:c2020_23(x))


The following defined symbols remain to be analysed:
timesIter
----------------------------------------

(29) RelTrsToTrsProof (UPPER BOUND(ID))
transformed relative TRS to TRS
----------------------------------------

(30)
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
----------------------------------------

(31) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT
----------------------------------------

(32)
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


----------------------------------------

(33) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   PROD(z0) -> c1(PRODITER(z0, s(0)))
Removed 13 trailing nodes:
   PLUS(0, z0) -> c6
   ISEMPTY(nil) -> c12
   GE(0, s(z0)) -> c19
   IFTIMES(true, z0, z1, z2, z3) -> c10
   TAIL(cons(z0, z1)) -> c17
   IFPROD(true, z0, z1) -> c3
   ISEMPTY(cons(z0, z1)) -> c13
   A -> c22
   HEAD(cons(z0, z1)) -> c15
   GE(z0, 0) -> c18
   TAIL(nil) -> c16
   HEAD(nil) -> c14
   A -> c21

----------------------------------------

(34)
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


----------------------------------------

(35) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(36)
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


----------------------------------------

(37) 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

----------------------------------------

(38)
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


----------------------------------------

(39) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID))
Converted S to standard rules, and D \ S as well as R to relative rules.
----------------------------------------

(40)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   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)))

The (relative) TRS S consists of the following 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))

Rewrite Strategy: INNERMOST
----------------------------------------

(41) RelTrsToTrsProof (UPPER BOUND(ID))
transformed relative TRS to TRS
----------------------------------------

(42)
Obligation:
The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   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)))
   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))

S is empty.
Rewrite Strategy: INNERMOST
----------------------------------------

(43) RelTrsToWeightedTrsProof (BOTH BOUNDS(ID, ID))
Transformed relative TRS to weighted TRS
----------------------------------------

(44)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) [1]
   TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) [1]
   TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) [1]
   IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) [1]
   GE(s(z0), s(z1)) -> c20(GE(z0, z1)) [1]
   PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) [1]
   IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) [1]
   IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) [1]
   ge(z0, 0) -> true [0]
   ge(0, s(z0)) -> false [0]
   ge(s(z0), s(z1)) -> ge(z0, z1) [0]
   plus(0, z0) -> z0 [0]
   plus(s(z0), z1) -> s(plus(z0, z1)) [0]
   isempty(nil) -> true [0]
   isempty(cons(z0, z1)) -> false [0]
   tail(nil) -> nil [0]
   tail(cons(z0, z1)) -> z1 [0]
   times(z0, z1) -> timesIter(z0, z1, 0, 0) [0]
   head(nil) -> error [0]
   head(cons(z0, z1)) -> z0 [0]
   timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) [0]
   ifTimes(true, z0, z1, z2, z3) -> z2 [0]
   ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) [0]

Rewrite Strategy: INNERMOST
----------------------------------------

(45) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(46)
Obligation:
Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) [1]
   TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) [1]
   TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) [1]
   IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) [1]
   GE(s(z0), s(z1)) -> c20(GE(z0, z1)) [1]
   PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) [1]
   IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) [1]
   IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) [1]
   ge(z0, 0) -> true [0]
   ge(0, s(z0)) -> false [0]
   ge(s(z0), s(z1)) -> ge(z0, z1) [0]
   plus(0, z0) -> z0 [0]
   plus(s(z0), z1) -> s(plus(z0, z1)) [0]
   isempty(nil) -> true [0]
   isempty(cons(z0, z1)) -> false [0]
   tail(nil) -> nil [0]
   tail(cons(z0, z1)) -> z1 [0]
   times(z0, z1) -> timesIter(z0, z1, 0, 0) [0]
   head(nil) -> error [0]
   head(cons(z0, z1)) -> z0 [0]
   timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) [0]
   ifTimes(true, z0, z1, z2, z3) -> z2 [0]
   ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) [0]

The TRS has the following type information:
PLUS :: s:0:error -> s:0:error -> c7
s :: s:0:error -> s:0:error
c7 :: c7 -> c7
TIMES :: s:0:error -> s:0:error -> c8
c8 :: c9 -> c8
TIMESITER :: s:0:error -> s:0:error -> s:0:error -> s:0:error -> c9
0 :: s:0:error
c9 :: c11 -> c20 -> c9
IFTIMES :: false:true -> s:0:error -> s:0:error -> s:0:error -> s:0:error -> c11
ge :: s:0:error -> s:0:error -> false:true
GE :: s:0:error -> s:0:error -> c20
false :: false:true
c11 :: c9 -> c7 -> c11
plus :: s:0:error -> s:0:error -> s:0:error
c20 :: c20 -> c20
PRODITER :: nil:cons -> s:0:error -> c2
c2 :: c4:c5 -> c2
IFPROD :: false:true -> nil:cons -> s:0:error -> c4:c5
isempty :: nil:cons -> false:true
c4 :: c2 -> c4:c5
tail :: nil:cons -> nil:cons
times :: s:0:error -> s:0:error -> s:0:error
head :: nil:cons -> s:0:error
c5 :: c2 -> c8 -> c4:c5
true :: false:true
nil :: nil:cons
cons :: s:0:error -> nil:cons -> nil:cons
timesIter :: s:0:error -> s:0:error -> s:0:error -> s:0:error -> s:0:error
error :: s:0:error
ifTimes :: false:true -> s:0:error -> s:0:error -> s:0:error -> s:0:error -> s:0:error

Rewrite Strategy: INNERMOST
----------------------------------------

(47) 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:

   PLUS_2
   TIMES_2
   TIMESITER_4
   IFTIMES_5
   GE_2
   PRODITER_2
   IFPROD_3

(c) The following functions are completely defined:

   ge_2
   plus_2
   isempty_1
   tail_1
   times_2
   head_1
   timesIter_4
   ifTimes_5

Due to the following rules being added:

   ge(v0, v1) -> null_ge [0]
   plus(v0, v1) -> null_plus [0]
   isempty(v0) -> null_isempty [0]
   tail(v0) -> nil [0]
   times(v0, v1) -> null_times [0]
   head(v0) -> null_head [0]
   timesIter(v0, v1, v2, v3) -> null_timesIter [0]
   ifTimes(v0, v1, v2, v3, v4) -> null_ifTimes [0]

And the following fresh constants:    null_ge, null_plus, null_isempty, null_times, null_head, null_timesIter, null_ifTimes, const, const1, const2, const3, const4, const5, const6

----------------------------------------

(48)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) [1]
   TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) [1]
   TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) [1]
   IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) [1]
   GE(s(z0), s(z1)) -> c20(GE(z0, z1)) [1]
   PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) [1]
   IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) [1]
   IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) [1]
   ge(z0, 0) -> true [0]
   ge(0, s(z0)) -> false [0]
   ge(s(z0), s(z1)) -> ge(z0, z1) [0]
   plus(0, z0) -> z0 [0]
   plus(s(z0), z1) -> s(plus(z0, z1)) [0]
   isempty(nil) -> true [0]
   isempty(cons(z0, z1)) -> false [0]
   tail(nil) -> nil [0]
   tail(cons(z0, z1)) -> z1 [0]
   times(z0, z1) -> timesIter(z0, z1, 0, 0) [0]
   head(nil) -> error [0]
   head(cons(z0, z1)) -> z0 [0]
   timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) [0]
   ifTimes(true, z0, z1, z2, z3) -> z2 [0]
   ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) [0]
   ge(v0, v1) -> null_ge [0]
   plus(v0, v1) -> null_plus [0]
   isempty(v0) -> null_isempty [0]
   tail(v0) -> nil [0]
   times(v0, v1) -> null_times [0]
   head(v0) -> null_head [0]
   timesIter(v0, v1, v2, v3) -> null_timesIter [0]
   ifTimes(v0, v1, v2, v3, v4) -> null_ifTimes [0]

The TRS has the following type information:
PLUS :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c7
s :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
c7 :: c7 -> c7
TIMES :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c8
c8 :: c9 -> c8
TIMESITER :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c9
0 :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
c9 :: c11 -> c20 -> c9
IFTIMES :: false:true:null_ge:null_isempty -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c11
ge :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> false:true:null_ge:null_isempty
GE :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c20
false :: false:true:null_ge:null_isempty
c11 :: c9 -> c7 -> c11
plus :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
c20 :: c20 -> c20
PRODITER :: nil:cons -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c2
c2 :: c4:c5 -> c2
IFPROD :: false:true:null_ge:null_isempty -> nil:cons -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c4:c5
isempty :: nil:cons -> false:true:null_ge:null_isempty
c4 :: c2 -> c4:c5
tail :: nil:cons -> nil:cons
times :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
head :: nil:cons -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
c5 :: c2 -> c8 -> c4:c5
true :: false:true:null_ge:null_isempty
nil :: nil:cons
cons :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> nil:cons -> nil:cons
timesIter :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
error :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
ifTimes :: false:true:null_ge:null_isempty -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_ge :: false:true:null_ge:null_isempty
null_plus :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_isempty :: false:true:null_ge:null_isempty
null_times :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_head :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_timesIter :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_ifTimes :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
const :: c7
const1 :: c8
const2 :: c9
const3 :: c11
const4 :: c20
const5 :: c2
const6 :: c4:c5

Rewrite Strategy: INNERMOST
----------------------------------------

(49) NarrowingProof (BOTH BOUNDS(ID, ID))
Narrowed the inner basic terms of all right-hand sides by a single narrowing step.
----------------------------------------

(50)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) [1]
   TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) [1]
   TIMESITER(0, z1, z2, z3) -> c9(IFTIMES(true, 0, z1, z2, z3), GE(z3, 0)) [1]
   TIMESITER(s(z0'), z1, z2, 0) -> c9(IFTIMES(false, s(z0'), z1, z2, 0), GE(0, s(z0'))) [1]
   TIMESITER(s(z1'), z1, z2, s(z0'')) -> c9(IFTIMES(ge(z0'', z1'), s(z1'), z1, z2, s(z0'')), GE(s(z0''), s(z1'))) [1]
   TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(null_ge, z0, z1, z2, z3), GE(z3, z0)) [1]
   IFTIMES(false, z0, 0, z2, z3) -> c11(TIMESITER(z0, 0, z2, s(z3)), PLUS(0, z2)) [1]
   IFTIMES(false, z0, s(z01), z2, z3) -> c11(TIMESITER(z0, s(z01), s(plus(z01, z2)), s(z3)), PLUS(s(z01), z2)) [1]
   IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, null_plus, s(z3)), PLUS(z1, z2)) [1]
   GE(s(z0), s(z1)) -> c20(GE(z0, z1)) [1]
   PRODITER(nil, z1) -> c2(IFPROD(true, nil, z1)) [1]
   PRODITER(cons(z02, z1''), z1) -> c2(IFPROD(false, cons(z02, z1''), z1)) [1]
   PRODITER(z0, z1) -> c2(IFPROD(null_isempty, z0, z1)) [1]
   IFPROD(false, nil, z1) -> c4(PRODITER(nil, times(z1, error))) [1]
   IFPROD(false, nil, z1) -> c4(PRODITER(nil, times(z1, null_head))) [1]
   IFPROD(false, cons(z03, z11), z1) -> c4(PRODITER(z11, times(z1, z03))) [1]
   IFPROD(false, cons(z03, z11), z1) -> c4(PRODITER(z11, times(z1, null_head))) [1]
   IFPROD(false, nil, z1) -> c4(PRODITER(nil, times(z1, error))) [1]
   IFPROD(false, cons(z04, z12), z1) -> c4(PRODITER(nil, times(z1, z04))) [1]
   IFPROD(false, z0, z1) -> c4(PRODITER(nil, times(z1, null_head))) [1]
   IFPROD(false, nil, z1) -> c5(PRODITER(nil, times(z1, error)), TIMES(z1, error)) [1]
   IFPROD(false, nil, z1) -> c5(PRODITER(nil, times(z1, error)), TIMES(z1, null_head)) [1]
   IFPROD(false, nil, z1) -> c5(PRODITER(nil, times(z1, null_head)), TIMES(z1, error)) [1]
   IFPROD(false, nil, z1) -> c5(PRODITER(nil, times(z1, null_head)), TIMES(z1, null_head)) [1]
   IFPROD(false, cons(z05, z13), z1) -> c5(PRODITER(z13, times(z1, z05)), TIMES(z1, z05)) [1]
   IFPROD(false, cons(z05, z13), z1) -> c5(PRODITER(z13, times(z1, z05)), TIMES(z1, null_head)) [1]
   IFPROD(false, cons(z05, z13), z1) -> c5(PRODITER(z13, times(z1, null_head)), TIMES(z1, z05)) [1]
   IFPROD(false, cons(z05, z13), z1) -> c5(PRODITER(z13, times(z1, null_head)), TIMES(z1, null_head)) [1]
   IFPROD(false, nil, z1) -> c5(PRODITER(nil, times(z1, error)), TIMES(z1, error)) [1]
   IFPROD(false, nil, z1) -> c5(PRODITER(nil, times(z1, error)), TIMES(z1, null_head)) [1]
   IFPROD(false, cons(z06, z14), z1) -> c5(PRODITER(nil, times(z1, z06)), TIMES(z1, z06)) [1]
   IFPROD(false, cons(z06, z14), z1) -> c5(PRODITER(nil, times(z1, z06)), TIMES(z1, null_head)) [1]
   IFPROD(false, nil, z1) -> c5(PRODITER(nil, times(z1, null_head)), TIMES(z1, error)) [1]
   IFPROD(false, cons(z07, z15), z1) -> c5(PRODITER(nil, times(z1, null_head)), TIMES(z1, z07)) [1]
   IFPROD(false, z0, z1) -> c5(PRODITER(nil, times(z1, null_head)), TIMES(z1, null_head)) [1]
   ge(z0, 0) -> true [0]
   ge(0, s(z0)) -> false [0]
   ge(s(z0), s(z1)) -> ge(z0, z1) [0]
   plus(0, z0) -> z0 [0]
   plus(s(z0), z1) -> s(plus(z0, z1)) [0]
   isempty(nil) -> true [0]
   isempty(cons(z0, z1)) -> false [0]
   tail(nil) -> nil [0]
   tail(cons(z0, z1)) -> z1 [0]
   times(z0, z1) -> timesIter(z0, z1, 0, 0) [0]
   head(nil) -> error [0]
   head(cons(z0, z1)) -> z0 [0]
   timesIter(0, z1, z2, z3) -> ifTimes(true, 0, z1, z2, z3) [0]
   timesIter(s(z08), z1, z2, 0) -> ifTimes(false, s(z08), z1, z2, 0) [0]
   timesIter(s(z16), z1, z2, s(z09)) -> ifTimes(ge(z09, z16), s(z16), z1, z2, s(z09)) [0]
   timesIter(z0, z1, z2, z3) -> ifTimes(null_ge, z0, z1, z2, z3) [0]
   ifTimes(true, z0, z1, z2, z3) -> z2 [0]
   ifTimes(false, z0, 0, z2, z3) -> timesIter(z0, 0, z2, s(z3)) [0]
   ifTimes(false, z0, s(z010), z2, z3) -> timesIter(z0, s(z010), s(plus(z010, z2)), s(z3)) [0]
   ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, null_plus, s(z3)) [0]
   ge(v0, v1) -> null_ge [0]
   plus(v0, v1) -> null_plus [0]
   isempty(v0) -> null_isempty [0]
   tail(v0) -> nil [0]
   times(v0, v1) -> null_times [0]
   head(v0) -> null_head [0]
   timesIter(v0, v1, v2, v3) -> null_timesIter [0]
   ifTimes(v0, v1, v2, v3, v4) -> null_ifTimes [0]

The TRS has the following type information:
PLUS :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c7
s :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
c7 :: c7 -> c7
TIMES :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c8
c8 :: c9 -> c8
TIMESITER :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c9
0 :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
c9 :: c11 -> c20 -> c9
IFTIMES :: false:true:null_ge:null_isempty -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c11
ge :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> false:true:null_ge:null_isempty
GE :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c20
false :: false:true:null_ge:null_isempty
c11 :: c9 -> c7 -> c11
plus :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
c20 :: c20 -> c20
PRODITER :: nil:cons -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c2
c2 :: c4:c5 -> c2
IFPROD :: false:true:null_ge:null_isempty -> nil:cons -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c4:c5
isempty :: nil:cons -> false:true:null_ge:null_isempty
c4 :: c2 -> c4:c5
tail :: nil:cons -> nil:cons
times :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
head :: nil:cons -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
c5 :: c2 -> c8 -> c4:c5
true :: false:true:null_ge:null_isempty
nil :: nil:cons
cons :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> nil:cons -> nil:cons
timesIter :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
error :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
ifTimes :: false:true:null_ge:null_isempty -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_ge :: false:true:null_ge:null_isempty
null_plus :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_isempty :: false:true:null_ge:null_isempty
null_times :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_head :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_timesIter :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_ifTimes :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
const :: c7
const1 :: c8
const2 :: c9
const3 :: c11
const4 :: c20
const5 :: c2
const6 :: c4:c5

Rewrite Strategy: INNERMOST
----------------------------------------

(51) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   false => 1
   true => 2
   nil => 0
   error => 1
   null_ge => 0
   null_plus => 0
   null_isempty => 0
   null_times => 0
   null_head => 0
   null_timesIter => 0
   null_ifTimes => 0
   const => 0
   const1 => 0
   const2 => 0
   const3 => 0
   const4 => 0
   const5 => 0
   const6 => 0

----------------------------------------

(52)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z1, z03)) :|: z11 >= 0, z1 >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z1, 0)) :|: z11 >= 0, z1 >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z1, z04)) :|: z04 >= 0, z1 >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z1, 1)) :|: z1 >= 0, z = 1, z' = 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z1, 0)) :|: z1 >= 0, z = 1, z' = 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z1, 0)) :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z1, z05)) + TIMES(z1, z05) :|: z1 >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z1, z05)) + TIMES(z1, 0) :|: z1 >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z1, 0)) + TIMES(z1, z05) :|: z1 >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z1, 0)) + TIMES(z1, 0) :|: z1 >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z1, z06)) + TIMES(z1, z06) :|: z1 >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z1, z06)) + TIMES(z1, 0) :|: z1 >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z1, 1)) + TIMES(z1, 1) :|: z1 >= 0, z = 1, z' = 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z1, 1)) + TIMES(z1, 0) :|: z1 >= 0, z = 1, z' = 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z1, 0)) + TIMES(z1, z07) :|: z' = 1 + z07 + z15, z15 >= 0, z1 >= 0, z07 >= 0, z = 1, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z1, 0)) + TIMES(z1, 1) :|: z1 >= 0, z = 1, z' = 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z1, 0)) + TIMES(z1, 0) :|: z1 >= 0, z = 1, z' = 0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z1, 0)) + TIMES(z1, 0) :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z0, z1, 0, 1 + z3) + PLUS(z1, z2) :|: z1 >= 0, z = 1, z0 >= 0, z5 = z3, z' = z0, z2 >= 0, z3 >= 0, z'' = z1, z4 = z2
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z0, 0, z2, 1 + z3) + PLUS(0, z2) :|: z'' = 0, z = 1, z0 >= 0, z5 = z3, z' = z0, z2 >= 0, z3 >= 0, z4 = z2
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z0, 1 + z01, 1 + plus(z01, z2), 1 + z3) + PLUS(1 + z01, z2) :|: z01 >= 0, z = 1, z0 >= 0, z5 = z3, z' = z0, z2 >= 0, z3 >= 0, z'' = 1 + z01, z4 = z2
   PLUS(z, z') -{ 1 }-> 1 + PLUS(z0, z1) :|: z1 >= 0, z = 1 + z0, z' = z1, z0 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z1) :|: z1 >= 0, z' = z1, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z1) :|: z1 >= 0, z02 >= 0, z' = z1, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z0, z1) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z0, z1, 0, 0) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z0'', z1'), 1 + z1', z1, z2, 1 + z0'') + GE(1 + z0'', 1 + z1') :|: z'' = z2, z1 >= 0, z = 1 + z1', z4 = 1 + z0'', z1' >= 0, z' = z1, z0'' >= 0, z2 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z1, z2, z3) + GE(z3, 0) :|: z'' = z2, z1 >= 0, z' = z1, z = 0, z4 = z3, z2 >= 0, z3 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + z0', z1, z2, 0) + GE(0, 1 + z0') :|: z'' = z2, z4 = 0, z1 >= 0, z0' >= 0, z' = z1, z = 1 + z0', z2 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z0, z1, z2, z3) + GE(z3, z0) :|: z'' = z2, z = z0, z1 >= 0, z' = z1, z0 >= 0, z4 = z3, z2 >= 0, z3 >= 0
   ge(z, z') -{ 0 }-> ge(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   ge(z, z') -{ 0 }-> 2 :|: z = z0, z0 >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z0 >= 0, z' = 1 + z0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z2 :|: z = 2, z1 >= 0, z0 >= 0, z5 = z3, z' = z0, z2 >= 0, z3 >= 0, z'' = z1, z4 = z2
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z0, z1, 0, 1 + z3) :|: z1 >= 0, z = 1, z0 >= 0, z5 = z3, z' = z0, z2 >= 0, z3 >= 0, z'' = z1, z4 = z2
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z0, 0, z2, 1 + z3) :|: z'' = 0, z = 1, z0 >= 0, z5 = z3, z' = z0, z2 >= 0, z3 >= 0, z4 = z2
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z0, 1 + z010, 1 + plus(z010, z2), 1 + z3) :|: z'' = 1 + z010, z = 1, z0 >= 0, z5 = z3, z' = z0, z010 >= 0, z2 >= 0, z3 >= 0, z4 = z2
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z5 = v4, v0 >= 0, v4 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z4 = v3, v2 >= 0, v3 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   plus(z, z') -{ 0 }-> z0 :|: z0 >= 0, z = 0, z' = z0
   plus(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   plus(z, z') -{ 0 }-> 1 + plus(z0, z1) :|: z1 >= 0, z = 1 + z0, z' = z1, z0 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   times(z, z') -{ 0 }-> timesIter(z0, z1, 0, 0) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   times(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z09, z16), 1 + z16, z1, z2, 1 + z09) :|: z = 1 + z16, z'' = z2, z4 = 1 + z09, z1 >= 0, z' = z1, z16 >= 0, z09 >= 0, z2 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z1, z2, z3) :|: z'' = z2, z1 >= 0, z' = z1, z = 0, z4 = z3, z2 >= 0, z3 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + z08, z1, z2, 0) :|: z08 >= 0, z'' = z2, z4 = 0, z1 >= 0, z = 1 + z08, z' = z1, z2 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z0, z1, z2, z3) :|: z'' = z2, z = z0, z1 >= 0, z' = z1, z0 >= 0, z4 = z3, z2 >= 0, z3 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z4 = v3, v2 >= 0, v3 >= 0


----------------------------------------

(53) SimplificationProof (BOTH BOUNDS(ID, ID))
Simplified the RNTS by moving equalities from the constraints into the right-hand sides.
----------------------------------------

(54)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + PLUS(z'', z4) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + PLUS(0, z4) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + PLUS(1 + (z'' - 1), z4) :|: z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ 1 }-> 1 + PLUS(z - 1, z') :|: z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0


----------------------------------------

(55) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID))
Found the following analysis order by SCC decomposition:

   { PLUS }
   { tail }
   { isempty }
   { ge }
   { head }
   { plus }
   { GE }
   { TIMESITER, IFTIMES }
   { timesIter, ifTimes }
   { TIMES }
   { times }
   { PRODITER, IFPROD }

----------------------------------------

(56)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + PLUS(z'', z4) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + PLUS(0, z4) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + PLUS(1 + (z'' - 1), z4) :|: z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ 1 }-> 1 + PLUS(z - 1, z') :|: z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {PLUS}, {tail}, {isempty}, {ge}, {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}

----------------------------------------

(57) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(58)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + PLUS(z'', z4) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + PLUS(0, z4) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + PLUS(1 + (z'' - 1), z4) :|: z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ 1 }-> 1 + PLUS(z - 1, z') :|: z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {PLUS}, {tail}, {isempty}, {ge}, {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}

----------------------------------------

(59) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: PLUS
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

----------------------------------------

(60)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + PLUS(z'', z4) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + PLUS(0, z4) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + PLUS(1 + (z'' - 1), z4) :|: z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ 1 }-> 1 + PLUS(z - 1, z') :|: z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {PLUS}, {tail}, {isempty}, {ge}, {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: ?, size: O(1) [0]

----------------------------------------

(61) 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: z

----------------------------------------

(62)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + PLUS(z'', z4) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + PLUS(0, z4) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + PLUS(1 + (z'' - 1), z4) :|: z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ 1 }-> 1 + PLUS(z - 1, z') :|: z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {tail}, {isempty}, {ge}, {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]

----------------------------------------

(63) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(64)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {tail}, {isempty}, {ge}, {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]

----------------------------------------

(65) 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

----------------------------------------

(66)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {tail}, {isempty}, {ge}, {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: ?, size: O(n^1) [z]

----------------------------------------

(67) 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: 0

----------------------------------------

(68)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {isempty}, {ge}, {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]

----------------------------------------

(69) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(70)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {isempty}, {ge}, {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]

----------------------------------------

(71) 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

----------------------------------------

(72)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {isempty}, {ge}, {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: ?, size: O(1) [2]

----------------------------------------

(73) 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: 0

----------------------------------------

(74)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {ge}, {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]

----------------------------------------

(75) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(76)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {ge}, {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]

----------------------------------------

(77) 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

----------------------------------------

(78)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {ge}, {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: ?, size: O(1) [2]

----------------------------------------

(79) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: ge
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

----------------------------------------

(80)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> ge(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z4 - 1, z - 1), 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]

----------------------------------------

(81) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(82)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(s2, 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: s2 >= 0, s2 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2, z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(s4, 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: s4 >= 0, s4 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]

----------------------------------------

(83) 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

----------------------------------------

(84)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(s2, 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: s2 >= 0, s2 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2, z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(s4, 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: s4 >= 0, s4 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {head}, {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]
  head: runtime: ?, size: O(n^1) [1 + z]

----------------------------------------

(85) 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: 0

----------------------------------------

(86)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(s2, 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: s2 >= 0, s2 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2, z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(s4, 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: s4 >= 0, s4 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]
  head: runtime: O(1) [0], size: O(n^1) [1 + z]

----------------------------------------

(87) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(88)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(s2, 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: s2 >= 0, s2 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2, z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(s4, 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: s4 >= 0, s4 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]
  head: runtime: O(1) [0], size: O(n^1) [1 + z]

----------------------------------------

(89) 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'

----------------------------------------

(90)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(s2, 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: s2 >= 0, s2 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2, z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(s4, 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: s4 >= 0, s4 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {plus}, {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]
  head: runtime: O(1) [0], size: O(n^1) [1 + z]
  plus: runtime: ?, size: O(n^1) [z + z']

----------------------------------------

(91) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: plus
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

----------------------------------------

(92)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) + s'' :|: s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(s2, 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: s2 >= 0, s2 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2, z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + plus(z'' - 1, z4), 1 + z5) :|: z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + plus(z - 1, z') :|: z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(s4, 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: s4 >= 0, s4 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]
  head: runtime: O(1) [0], size: O(n^1) [1 + z]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']

----------------------------------------

(93) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(94)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + s5, 1 + z5) + s'' :|: s5 >= 0, s5 <= z'' - 1 + z4, s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(s2, 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: s2 >= 0, s2 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2, z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + s7, 1 + z5) :|: s7 >= 0, s7 <= z'' - 1 + z4, z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + s6 :|: s6 >= 0, s6 <= z - 1 + z', z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(s4, 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: s4 >= 0, s4 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]
  head: runtime: O(1) [0], size: O(n^1) [1 + z]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']

----------------------------------------

(95) 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: 0

----------------------------------------

(96)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + s5, 1 + z5) + s'' :|: s5 >= 0, s5 <= z'' - 1 + z4, s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(s2, 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: s2 >= 0, s2 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2, z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + s7, 1 + z5) :|: s7 >= 0, s7 <= z'' - 1 + z4, z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + s6 :|: s6 >= 0, s6 <= z - 1 + z', z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(s4, 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: s4 >= 0, s4 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {GE}, {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]
  head: runtime: O(1) [0], size: O(n^1) [1 + z]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  GE: runtime: ?, size: O(1) [0]

----------------------------------------

(97) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: GE
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: z'

----------------------------------------

(98)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 1 }-> 1 + GE(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + s5, 1 + z5) + s'' :|: s5 >= 0, s5 <= z'' - 1 + z4, s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(s2, 1 + (z - 1), z', z'', 1 + (z4 - 1)) + GE(1 + (z4 - 1), 1 + (z - 1)) :|: s2 >= 0, s2 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + GE(z4, 0) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + GE(0, 1 + (z - 1)) :|: z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(0, z, z', z'', z4) + GE(z4, z) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2, z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + s7, 1 + z5) :|: s7 >= 0, s7 <= z'' - 1 + z4, z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + s6 :|: s6 >= 0, s6 <= z - 1 + z', z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(s4, 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: s4 >= 0, s4 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]
  head: runtime: O(1) [0], size: O(n^1) [1 + z]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  GE: runtime: O(n^1) [z'], size: O(1) [0]

----------------------------------------

(99) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(100)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ z' }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + s5, 1 + z5) + s'' :|: s5 >= 0, s5 <= z'' - 1 + z4, s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 + z }-> 1 + IFTIMES(s2, 1 + (z - 1), z', z'', 1 + (z4 - 1)) + s10 :|: s10 >= 0, s10 <= 0, s2 >= 0, s2 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 + z }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + s9 :|: s9 >= 0, s9 <= 0, z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 + z }-> 1 + IFTIMES(0, z, z', z'', z4) + s11 :|: s11 >= 0, s11 <= 0, z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2, z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + s7, 1 + z5) :|: s7 >= 0, s7 <= z'' - 1 + z4, z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + s6 :|: s6 >= 0, s6 <= z - 1 + z', z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(s4, 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: s4 >= 0, s4 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]
  head: runtime: O(1) [0], size: O(n^1) [1 + z]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  GE: runtime: O(n^1) [z'], size: O(1) [0]

----------------------------------------

(101) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: TIMESITER
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

Computed SIZE bound using CoFloCo for: IFTIMES
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 1

----------------------------------------

(102)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ z' }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + s5, 1 + z5) + s'' :|: s5 >= 0, s5 <= z'' - 1 + z4, s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 + z }-> 1 + IFTIMES(s2, 1 + (z - 1), z', z'', 1 + (z4 - 1)) + s10 :|: s10 >= 0, s10 <= 0, s2 >= 0, s2 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 + z }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + s9 :|: s9 >= 0, s9 <= 0, z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 + z }-> 1 + IFTIMES(0, z, z', z'', z4) + s11 :|: s11 >= 0, s11 <= 0, z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2, z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + s7, 1 + z5) :|: s7 >= 0, s7 <= z'' - 1 + z4, z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + s6 :|: s6 >= 0, s6 <= z - 1 + z', z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(s4, 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: s4 >= 0, s4 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]
  head: runtime: O(1) [0], size: O(n^1) [1 + z]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  GE: runtime: O(n^1) [z'], size: O(1) [0]
  TIMESITER: runtime: ?, size: O(1) [0]
  IFTIMES: runtime: ?, size: O(1) [1]

----------------------------------------

(103) 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: ?

----------------------------------------

(104)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ z' }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', z03)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z11, times(z'', 0)) :|: z11 >= 0, z'' >= 0, z = 1, z03 >= 0, z' = 1 + z03 + z11
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z04)) :|: z04 >= 0, z'' >= 0, z = 1, z' = 1 + z04 + z12, z12 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) :|: z'' >= 0, z = 1, z' >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', z05)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', z05) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(z13, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 1 + z05 + z13, z05 >= 0, z13 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', z06) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', z06)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z06 >= 0, z' = 1 + z06 + z14, z14 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 1)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', z07) :|: z' = 1 + z07 + z15, z15 >= 0, z'' >= 0, z07 >= 0, z = 1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 1) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' = 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(0, times(z'', 0)) + TIMES(z'', 0) :|: z'' >= 0, z = 1, z' >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', z'', 0, 1 + z5) + s1 :|: s1 >= 0, s1 <= 0, z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z', 0, z4, 1 + z5) + s' :|: s' >= 0, s' <= 0, z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 + z'' }-> 1 + TIMESITER(z', 1 + (z'' - 1), 1 + s5, 1 + z5) + s'' :|: s5 >= 0, s5 <= z'' - 1 + z4, s'' >= 0, s'' <= 0, z'' - 1 >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   PLUS(z, z') -{ z }-> 1 + s :|: s >= 0, s <= 0, z' >= 0, z - 1 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(2, 0, z') :|: z' >= 0, z = 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(1, 1 + z02 + z1'', z') :|: z' >= 0, z02 >= 0, z = 1 + z02 + z1'', z1'' >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(0, z, z') :|: z' >= 0, z >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z, z', 0, 0) :|: z' >= 0, z >= 0
   TIMESITER(z, z', z'', z4) -{ 1 + z }-> 1 + IFTIMES(s2, 1 + (z - 1), z', z'', 1 + (z4 - 1)) + s10 :|: s10 >= 0, s10 <= 0, s2 >= 0, s2 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(2, 0, z', z'', z4) + s8 :|: s8 >= 0, s8 <= 0, z' >= 0, z = 0, z'' >= 0, z4 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 + z }-> 1 + IFTIMES(1, 1 + (z - 1), z', z'', 0) + s9 :|: s9 >= 0, s9 <= 0, z4 = 0, z' >= 0, z - 1 >= 0, z'' >= 0
   TIMESITER(z, z', z'', z4) -{ 1 + z }-> 1 + IFTIMES(0, z, z', z'', z4) + s11 :|: s11 >= 0, s11 <= 0, z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   ge(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2, z' - 1 >= 0, z - 1 >= 0
   ge(z, z') -{ 0 }-> 2 :|: z >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: z >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z4 :|: z = 2, z'' >= 0, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', z'', 0, 1 + z5) :|: z'' >= 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 0, z4, 1 + z5) :|: z'' = 0, z = 1, z' >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z', 1 + (z'' - 1), 1 + s7, 1 + z5) :|: s7 >= 0, s7 <= z'' - 1 + z4, z = 1, z' >= 0, z'' - 1 >= 0, z4 >= 0, z5 >= 0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z >= 0, z5 >= 0, z' >= 0, z'' >= 0, z4 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: z >= 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + s6 :|: s6 >= 0, s6 <= z - 1 + z', z' >= 0, z - 1 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> timesIter(z, z', 0, 0) :|: z' >= 0, z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(s4, 1 + (z - 1), z', z'', 1 + (z4 - 1)) :|: s4 >= 0, s4 <= 2, z' >= 0, z - 1 >= 0, z4 - 1 >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(2, 0, z', z'', z4) :|: z' >= 0, z = 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(1, 1 + (z - 1), z', z'', 0) :|: z - 1 >= 0, z4 = 0, z' >= 0, z'' >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(0, z, z', z'', z4) :|: z' >= 0, z >= 0, z'' >= 0, z4 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z4 >= 0

Function symbols to be analyzed: {TIMESITER,IFTIMES}, {timesIter,ifTimes}, {TIMES}, {times}, {PRODITER,IFPROD}
Previous analysis results are:
  PLUS: runtime: O(n^1) [z], size: O(1) [0]
  tail: runtime: O(1) [0], size: O(n^1) [z]
  isempty: runtime: O(1) [0], size: O(1) [2]
  ge: runtime: O(1) [0], size: O(1) [2]
  head: runtime: O(1) [0], size: O(n^1) [1 + z]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  GE: runtime: O(n^1) [z'], size: O(1) [0]
  TIMESITER: runtime: INF, size: O(1) [0]
  IFTIMES: runtime: ?, size: O(1) [1]

----------------------------------------

(105) 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:

   ge(v0, v1) -> null_ge [0]
   plus(v0, v1) -> null_plus [0]
   isempty(v0) -> null_isempty [0]
   tail(v0) -> null_tail [0]
   times(v0, v1) -> null_times [0]
   head(v0) -> null_head [0]
   timesIter(v0, v1, v2, v3) -> null_timesIter [0]
   ifTimes(v0, v1, v2, v3, v4) -> null_ifTimes [0]
   PLUS(v0, v1) -> null_PLUS [0]
   IFTIMES(v0, v1, v2, v3, v4) -> null_IFTIMES [0]
   GE(v0, v1) -> null_GE [0]
   IFPROD(v0, v1, v2) -> null_IFPROD [0]

And the following fresh constants:    null_ge, null_plus, null_isempty, null_tail, null_times, null_head, null_timesIter, null_ifTimes, null_PLUS, null_IFTIMES, null_GE, null_IFPROD, const, const1, const2

----------------------------------------

(106)
Obligation:
Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   PLUS(s(z0), z1) -> c7(PLUS(z0, z1)) [1]
   TIMES(z0, z1) -> c8(TIMESITER(z0, z1, 0, 0)) [1]
   TIMESITER(z0, z1, z2, z3) -> c9(IFTIMES(ge(z3, z0), z0, z1, z2, z3), GE(z3, z0)) [1]
   IFTIMES(false, z0, z1, z2, z3) -> c11(TIMESITER(z0, z1, plus(z1, z2), s(z3)), PLUS(z1, z2)) [1]
   GE(s(z0), s(z1)) -> c20(GE(z0, z1)) [1]
   PRODITER(z0, z1) -> c2(IFPROD(isempty(z0), z0, z1)) [1]
   IFPROD(false, z0, z1) -> c4(PRODITER(tail(z0), times(z1, head(z0)))) [1]
   IFPROD(false, z0, z1) -> c5(PRODITER(tail(z0), times(z1, head(z0))), TIMES(z1, head(z0))) [1]
   ge(z0, 0) -> true [0]
   ge(0, s(z0)) -> false [0]
   ge(s(z0), s(z1)) -> ge(z0, z1) [0]
   plus(0, z0) -> z0 [0]
   plus(s(z0), z1) -> s(plus(z0, z1)) [0]
   isempty(nil) -> true [0]
   isempty(cons(z0, z1)) -> false [0]
   tail(nil) -> nil [0]
   tail(cons(z0, z1)) -> z1 [0]
   times(z0, z1) -> timesIter(z0, z1, 0, 0) [0]
   head(nil) -> error [0]
   head(cons(z0, z1)) -> z0 [0]
   timesIter(z0, z1, z2, z3) -> ifTimes(ge(z3, z0), z0, z1, z2, z3) [0]
   ifTimes(true, z0, z1, z2, z3) -> z2 [0]
   ifTimes(false, z0, z1, z2, z3) -> timesIter(z0, z1, plus(z1, z2), s(z3)) [0]
   ge(v0, v1) -> null_ge [0]
   plus(v0, v1) -> null_plus [0]
   isempty(v0) -> null_isempty [0]
   tail(v0) -> null_tail [0]
   times(v0, v1) -> null_times [0]
   head(v0) -> null_head [0]
   timesIter(v0, v1, v2, v3) -> null_timesIter [0]
   ifTimes(v0, v1, v2, v3, v4) -> null_ifTimes [0]
   PLUS(v0, v1) -> null_PLUS [0]
   IFTIMES(v0, v1, v2, v3, v4) -> null_IFTIMES [0]
   GE(v0, v1) -> null_GE [0]
   IFPROD(v0, v1, v2) -> null_IFPROD [0]

The TRS has the following type information:
PLUS :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c7:null_PLUS
s :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
c7 :: c7:null_PLUS -> c7:null_PLUS
TIMES :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c8
c8 :: c9 -> c8
TIMESITER :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c9
0 :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
c9 :: c11:null_IFTIMES -> c20:null_GE -> c9
IFTIMES :: false:true:null_ge:null_isempty -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c11:null_IFTIMES
ge :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> false:true:null_ge:null_isempty
GE :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c20:null_GE
false :: false:true:null_ge:null_isempty
c11 :: c9 -> c7:null_PLUS -> c11:null_IFTIMES
plus :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
c20 :: c20:null_GE -> c20:null_GE
PRODITER :: nil:cons:null_tail -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c2
c2 :: c4:c5:null_IFPROD -> c2
IFPROD :: false:true:null_ge:null_isempty -> nil:cons:null_tail -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> c4:c5:null_IFPROD
isempty :: nil:cons:null_tail -> false:true:null_ge:null_isempty
c4 :: c2 -> c4:c5:null_IFPROD
tail :: nil:cons:null_tail -> nil:cons:null_tail
times :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
head :: nil:cons:null_tail -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
c5 :: c2 -> c8 -> c4:c5:null_IFPROD
true :: false:true:null_ge:null_isempty
nil :: nil:cons:null_tail
cons :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> nil:cons:null_tail -> nil:cons:null_tail
timesIter :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
error :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
ifTimes :: false:true:null_ge:null_isempty -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes -> s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_ge :: false:true:null_ge:null_isempty
null_plus :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_isempty :: false:true:null_ge:null_isempty
null_tail :: nil:cons:null_tail
null_times :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_head :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_timesIter :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_ifTimes :: s:0:error:null_plus:null_times:null_head:null_timesIter:null_ifTimes
null_PLUS :: c7:null_PLUS
null_IFTIMES :: c11:null_IFTIMES
null_GE :: c20:null_GE
null_IFPROD :: c4:c5:null_IFPROD
const :: c8
const1 :: c9
const2 :: c2

Rewrite Strategy: INNERMOST
----------------------------------------

(107) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   false => 1
   true => 2
   nil => 0
   error => 1
   null_ge => 0
   null_plus => 0
   null_isempty => 0
   null_tail => 0
   null_times => 0
   null_head => 0
   null_timesIter => 0
   null_ifTimes => 0
   null_PLUS => 0
   null_IFTIMES => 0
   null_GE => 0
   null_IFPROD => 0
   const => 0
   const1 => 0
   const2 => 0

----------------------------------------

(108)
Obligation:
Complexity RNTS consisting of the following rules:

   GE(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   GE(z, z') -{ 1 }-> 1 + GE(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   IFPROD(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(tail(z0), times(z1, head(z0))) :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   IFPROD(z, z', z'') -{ 1 }-> 1 + PRODITER(tail(z0), times(z1, head(z0))) + TIMES(z1, head(z0)) :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   IFTIMES(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z5 = v4, v0 >= 0, v4 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z4 = v3, v2 >= 0, v3 >= 0
   IFTIMES(z, z', z'', z4, z5) -{ 1 }-> 1 + TIMESITER(z0, z1, plus(z1, z2), 1 + z3) + PLUS(z1, z2) :|: z1 >= 0, z = 1, z0 >= 0, z5 = z3, z' = z0, z2 >= 0, z3 >= 0, z'' = z1, z4 = z2
   PLUS(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   PLUS(z, z') -{ 1 }-> 1 + PLUS(z0, z1) :|: z1 >= 0, z = 1 + z0, z' = z1, z0 >= 0
   PRODITER(z, z') -{ 1 }-> 1 + IFPROD(isempty(z0), z0, z1) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   TIMES(z, z') -{ 1 }-> 1 + TIMESITER(z0, z1, 0, 0) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   TIMESITER(z, z', z'', z4) -{ 1 }-> 1 + IFTIMES(ge(z3, z0), z0, z1, z2, z3) + GE(z3, z0) :|: z'' = z2, z = z0, z1 >= 0, z' = z1, z0 >= 0, z4 = z3, z2 >= 0, z3 >= 0
   ge(z, z') -{ 0 }-> ge(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   ge(z, z') -{ 0 }-> 2 :|: z = z0, z0 >= 0, z' = 0
   ge(z, z') -{ 0 }-> 1 :|: z0 >= 0, z' = 1 + z0, z = 0
   ge(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   head(z) -{ 0 }-> z0 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   head(z) -{ 0 }-> 1 :|: z = 0
   head(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> z2 :|: z = 2, z1 >= 0, z0 >= 0, z5 = z3, z' = z0, z2 >= 0, z3 >= 0, z'' = z1, z4 = z2
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> timesIter(z0, z1, plus(z1, z2), 1 + z3) :|: z1 >= 0, z = 1, z0 >= 0, z5 = z3, z' = z0, z2 >= 0, z3 >= 0, z'' = z1, z4 = z2
   ifTimes(z, z', z'', z4, z5) -{ 0 }-> 0 :|: z5 = v4, v0 >= 0, v4 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z4 = v3, v2 >= 0, v3 >= 0
   isempty(z) -{ 0 }-> 2 :|: z = 0
   isempty(z) -{ 0 }-> 1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   isempty(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   plus(z, z') -{ 0 }-> z0 :|: z0 >= 0, z = 0, z' = z0
   plus(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   plus(z, z') -{ 0 }-> 1 + plus(z0, z1) :|: z1 >= 0, z = 1 + z0, z' = z1, z0 >= 0
   tail(z) -{ 0 }-> z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   tail(z) -{ 0 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   times(z, z') -{ 0 }-> timesIter(z0, z1, 0, 0) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   times(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   timesIter(z, z', z'', z4) -{ 0 }-> ifTimes(ge(z3, z0), z0, z1, z2, z3) :|: z'' = z2, z = z0, z1 >= 0, z' = z1, z0 >= 0, z4 = z3, z2 >= 0, z3 >= 0
   timesIter(z, z', z'', z4) -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z4 = v3, v2 >= 0, v3 >= 0

Only complete derivations are relevant for the runtime complexity.

----------------------------------------

(109) 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)))

----------------------------------------

(110)
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


----------------------------------------

(111) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   TIMESITER(0, x1, x2, z0) -> c9(IFTIMES(true, 0, x1, x2, z0), GE(z0, 0))

----------------------------------------

(112)
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


----------------------------------------

(113) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(114)
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


----------------------------------------

(115) 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))

----------------------------------------

(116)
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


----------------------------------------

(117) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   PRODITER(nil, x1) -> c2(IFPROD(true, nil, x1))

----------------------------------------

(118)
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


----------------------------------------

(119) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false

----------------------------------------

(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))
   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


----------------------------------------

(121) 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)))))

----------------------------------------

(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))
   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


----------------------------------------

(123) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFPROD(false, nil, x1) -> c4(PRODITER(nil, times(x1, head(nil))))

----------------------------------------

(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))
   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


----------------------------------------

(125) 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)))

----------------------------------------

(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))
   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


----------------------------------------

(127) 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]

----------------------------------------

(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))
   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


----------------------------------------

(129) 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))))

----------------------------------------

(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(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


----------------------------------------

(131) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(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(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


----------------------------------------

(133) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(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(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


----------------------------------------

(135) 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)))

----------------------------------------

(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(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


----------------------------------------

(137) 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, 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)) = 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) = [1]
   POL(ge(x_1, x_2)) = [1] + x_1 + x_2
   POL(head(x_1)) = 0
   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]

----------------------------------------

(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(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


----------------------------------------

(139) 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)))

----------------------------------------

(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, 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


----------------------------------------

(141) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(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, 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


----------------------------------------

(143) 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)))

----------------------------------------

(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) -> 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


----------------------------------------

(145) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFPROD(false, nil, x1) -> c4(PRODITER(nil, timesIter(x1, head(nil), 0, 0)))

----------------------------------------

(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) -> 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


----------------------------------------

(147) 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)))

----------------------------------------

(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) -> 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


----------------------------------------

(149) 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]

----------------------------------------

(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) -> 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


----------------------------------------

(151) 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)))

----------------------------------------

(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))
   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


----------------------------------------

(153) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFPROD(false, nil, x0) -> c4(PRODITER(nil, 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))
   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


----------------------------------------

(155) 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)))

----------------------------------------

(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))
   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


----------------------------------------

(157) 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]

----------------------------------------

(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))
   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


----------------------------------------

(159) 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)))

----------------------------------------

(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))
   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


----------------------------------------

(161) 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)))

----------------------------------------

(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))
   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


----------------------------------------

(163) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(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))
   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


----------------------------------------

(165) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(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))
   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


----------------------------------------

(167) 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)))

----------------------------------------

(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))
   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


----------------------------------------

(169) 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]

----------------------------------------

(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))
   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


----------------------------------------

(171) 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)) = 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]

----------------------------------------

(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))
   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


----------------------------------------

(173) 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))))

----------------------------------------

(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))
   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


----------------------------------------

(175) 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]

----------------------------------------

(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))
   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


----------------------------------------

(177) 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))))

----------------------------------------

(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))
   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


----------------------------------------

(179) 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))

----------------------------------------

(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))
   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


----------------------------------------

(181) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   IFPROD(false, nil, x0) -> c5(TIMES(x0, error))

----------------------------------------

(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))
   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


----------------------------------------

(183) 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)))

----------------------------------------

(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))
   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


----------------------------------------

(185) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFPROD(false, nil, x0) -> c(PRODITER(nil, times(x0, error)))

----------------------------------------

(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))
   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


----------------------------------------

(187) 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))

----------------------------------------

(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))
   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


----------------------------------------

(189) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   IFPROD(false, nil, x0) -> c(TIMES(x0, error))

----------------------------------------

(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:
   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


----------------------------------------

(191) 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))))

----------------------------------------

(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:
   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


----------------------------------------

(193) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(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:
   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


----------------------------------------

(195) 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)))
----------------------------------------

(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:
   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


----------------------------------------

(197) 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)))
----------------------------------------

(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:
   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


----------------------------------------

(199) 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))

----------------------------------------

(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:
   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, 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)))
   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


----------------------------------------

(201) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(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:
   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, 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(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)))
   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


----------------------------------------

(203) 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)))
----------------------------------------

(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:
   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, 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(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)))
   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))
   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))
   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


----------------------------------------

(205) 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))

----------------------------------------

(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:
   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, 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(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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   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


----------------------------------------

(207) 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)))
----------------------------------------

(208)
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(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(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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   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


----------------------------------------

(209) 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)))
----------------------------------------

(210)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   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


----------------------------------------

(211) 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)))
----------------------------------------

(212)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 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))
   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


----------------------------------------

(213) 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))

----------------------------------------

(214)
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))
   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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   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))
   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))
   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, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2

Compound Symbols:   c8_1, c20_1, c2_1, c9_1, c4_1, c5_2, c5_1, c1_1, c_1, c9_2, c11_2, c3_1, c7_1


----------------------------------------

(215) 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)))
----------------------------------------

(216)
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))
   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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   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))
   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))
   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, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2

Compound Symbols:   c8_1, c20_1, c2_1, c9_1, c4_1, c5_2, c5_1, c1_1, c_1, c9_2, c11_2, c3_1, c7_1


----------------------------------------

(217) 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)))
----------------------------------------

(218)
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))
   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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   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))
   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))
   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, TIMESITER_4, IFPROD_3, IFTIMES_5, PLUS_2

Compound Symbols:   c8_1, c20_1, c2_1, c9_1, c4_1, c5_2, c5_1, c1_1, c_1, c9_2, c11_2, c3_1, c7_1


----------------------------------------

(219) 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)))))

----------------------------------------

(220)
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))
   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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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:
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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:   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, c5_2, c5_1, c1_1, c_1, c9_2, c11_2, c3_1, c7_1


----------------------------------------

(221) 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)))

----------------------------------------

(222)
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, 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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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:
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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:   TIMES_2, GE_2, PRODITER_2, IFPROD_3, TIMESITER_4, IFTIMES_5, PLUS_2

Compound Symbols:   c8_1, c20_1, c2_1, c4_1, c5_2, c5_1, c1_1, c_1, c9_2, c9_1, c11_2, c3_1, c7_1


----------------------------------------

(223) 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)))

----------------------------------------

(224)
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, 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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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:
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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:   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


----------------------------------------

(225) 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))
----------------------------------------

(226)
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, 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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(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))
   IFPROD(false, x0, z0) -> c5(PRODITER(tail(x0), ifTimes(ge(0, z0), z0, head(x0), 0, 0)), TIMES(z0, head(x0)))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(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


----------------------------------------

(227) 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))))

----------------------------------------

(228)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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:
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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:   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


----------------------------------------

(229) 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))))

----------------------------------------

(230)
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, 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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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:
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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, 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


----------------------------------------

(231) 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))
----------------------------------------

(232)
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, 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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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, 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


----------------------------------------

(233) 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))
----------------------------------------

(234)
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, 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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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, 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, c1_1, c5_1, c_1, c9_2, c9_1, c4_1, c11_2, c3_1, c7_1


----------------------------------------

(235) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   IFPROD(false, nil, z0) -> c5(TIMES(z0, error))

----------------------------------------

(236)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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) -> 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


----------------------------------------

(237) 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)))
----------------------------------------

(238)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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) -> 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


----------------------------------------

(239) 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))
----------------------------------------

(240)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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) -> 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


----------------------------------------

(241) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   IFPROD(false, nil, z0) -> c1(TIMES(z0, error))

----------------------------------------

(242)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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, 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


----------------------------------------

(243) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   head(nil) -> error

----------------------------------------

(244)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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, 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


----------------------------------------

(245) 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))))

----------------------------------------

(246)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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, 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


----------------------------------------

(247) 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))))

----------------------------------------

(248)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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, 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


----------------------------------------

(249) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   times(z0, z1) -> timesIter(z0, z1, 0, 0)

----------------------------------------

(250)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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, 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


----------------------------------------

(251) 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))

----------------------------------------

(252)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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, 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


----------------------------------------

(253) 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))))

----------------------------------------

(254)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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, 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, c7_1, c5_2, c1_1, c5_1


----------------------------------------

(255) 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)))

----------------------------------------

(256)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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, 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, c7_1, c5_2, c1_1, c5_1, c_1


----------------------------------------

(257) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFPROD(false, nil, x0) -> c(PRODITER(nil, timesIter(x0, error, 0, 0)))

----------------------------------------

(258)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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, 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, c7_1, c5_2, c1_1, c5_1, c_1


----------------------------------------

(259) 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)))))

----------------------------------------

(260)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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, c7_1, c5_2, c1_1, c5_1, c_1, c9_2


----------------------------------------

(261) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(262)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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, c7_1, c5_2, c1_1, c5_1, c_1, c9_2


----------------------------------------

(263) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(264)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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, c7_1, c5_2, c1_1, c5_1, c_1, c9_2, c6_1


----------------------------------------

(265) 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)))

----------------------------------------

(266)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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, c7_1, c5_2, c1_1, c5_1, c_1, c9_2, c6_1


----------------------------------------

(267) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFPROD(false, nil, x0) -> c4(PRODITER(nil, ifTimes(ge(0, x0), x0, error, 0, 0)))

----------------------------------------

(268)
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)))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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, c7_1, c5_2, c1_1, c5_1, c_1, c9_2, c6_1


----------------------------------------

(269) 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)))

----------------------------------------

(270)
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))))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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, IFTIMES_5, IFPROD_3, PLUS_2

Compound Symbols:   c8_1, c20_1, c2_1, c9_1, c11_2, c3_1, c4_1, c7_1, c5_2, c1_1, c5_1, c_1, c9_2, c6_1


----------------------------------------

(271) 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))))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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)) = [1] + 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)) = [1] + 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)) = x_2
   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]

----------------------------------------

(272)
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))))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, ifTimes(ge(0, z2), z2, head(cons(z0, z1)), 0, 0)))
   TIMESITER(s(z0), x1, 0, 0) -> c9(IFTIMES(false, s(z0), x1, 0, 0))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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, IFTIMES_5, IFPROD_3, PLUS_2

Compound Symbols:   c8_1, c20_1, c2_1, c9_1, c11_2, c3_1, c4_1, c7_1, c5_2, c1_1, c5_1, c_1, c9_2, c6_1


----------------------------------------

(273) 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)))

----------------------------------------

(274)
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))))
   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))
   IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0)))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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, IFTIMES_5, IFPROD_3, PLUS_2

Compound Symbols:   c8_1, c20_1, c2_1, c9_1, c11_2, c3_1, c4_1, c7_1, c5_2, c1_1, c5_1, c_1, c9_2, c6_1


----------------------------------------

(275) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFPROD(false, cons(z0, z1), z2) -> c4(PRODITER(z1, timesIter(z2, z0, 0, 0))) by 
   IFPROD(false, cons(z1, x1), z0) -> c4(PRODITER(x1, ifTimes(ge(0, z0), z0, z1, 0, 0)))

----------------------------------------

(276)
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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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))
   PLUS(s(s(y0)), z1) -> c7(PLUS(s(y0), z1))
   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(z0, z1), z2) -> c5(PRODITER(tail(cons(z0, z1)), timesIter(z2, z0, 0, 0)), TIMES(z2, z0))
   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))))
   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, IFTIMES_5, PLUS_2, IFPROD_3

Compound Symbols:   c8_1, c20_1, c2_1, c9_1, c11_2, c3_1, c7_1, c4_1, c5_2, c1_1, c5_1, c_1, c9_2, c6_1


----------------------------------------

(277) RelTrsToWeightedTrsProof (UPPER BOUND(ID))
Transformed relative TRS to weighted TRS
----------------------------------------

(278)
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
----------------------------------------

(279) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(280)
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
----------------------------------------

(281) 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

----------------------------------------

(282)
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
----------------------------------------

(283) NarrowingProof (BOTH BOUNDS(ID, ID))
Narrowed the inner basic terms of all right-hand sides by a single narrowing step.
----------------------------------------

(284)
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
----------------------------------------

(285) 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

----------------------------------------

(286)
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


----------------------------------------

(287) SimplificationProof (BOTH BOUNDS(ID, ID))
Simplified the RNTS by moving equalities from the constraints into the right-hand sides.
----------------------------------------

(288)
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


----------------------------------------

(289) 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 }

----------------------------------------

(290)
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}

----------------------------------------

(291) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(292)
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}

----------------------------------------

(293) 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'

----------------------------------------

(294)
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']

----------------------------------------

(295) 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

----------------------------------------

(296)
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']

----------------------------------------

(297) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(298)
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']

----------------------------------------

(299) 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

----------------------------------------

(300)
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]

----------------------------------------

(301) 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

----------------------------------------

(302)
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]

----------------------------------------

(303) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(304)
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]

----------------------------------------

(305) 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

----------------------------------------

(306)
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]

----------------------------------------

(307) 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'

----------------------------------------

(308)
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]

----------------------------------------

(309) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(310)
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]

----------------------------------------

(311) 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'

----------------------------------------

(312)
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']

----------------------------------------

(313) 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

----------------------------------------

(314)
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']

----------------------------------------

(315) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(316)
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']

----------------------------------------

(317) 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''

----------------------------------------

(318)
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'']

----------------------------------------

(319) 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'

----------------------------------------

(320)
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'']

----------------------------------------

(321) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(322)
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'']

----------------------------------------

(323) 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

----------------------------------------

(324)
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]

----------------------------------------

(325) 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

----------------------------------------

(326)
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]

----------------------------------------

(327) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

(328)
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]

----------------------------------------

(329) 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: ?

----------------------------------------

(330)
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

----------------------------------------

(331) 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: ?

----------------------------------------

(332)
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

----------------------------------------

(333) 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

----------------------------------------

(334)
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
----------------------------------------

(335) 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

----------------------------------------

(336)
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.