KILLED proof of input_aMEi6Xzm9g.trs # AProVE Commit ID: aff8ecad908e01718a4c36e68d2e55d5e0f16e15 fuhs 20220216 unpublished The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). (0) CpxTRS (1) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms] (2) CpxTRS (3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms] (4) CpxTRS (5) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms] (6) CpxWeightedTrs (7) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms] (8) CpxTypedWeightedTrs (9) CompletionProof [UPPER BOUND(ID), 0 ms] (10) CpxTypedWeightedCompleteTrs (11) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (12) CpxTypedWeightedCompleteTrs (13) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 13 ms] (14) CpxRNTS (15) SimplificationProof [BOTH BOUNDS(ID, ID), 15 ms] (16) CpxRNTS (17) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms] (18) CpxRNTS (19) ResultPropagationProof [UPPER BOUND(ID), 5 ms] (20) CpxRNTS (21) IntTrsBoundProof [UPPER BOUND(ID), 233 ms] (22) CpxRNTS (23) IntTrsBoundProof [UPPER BOUND(ID), 27 ms] (24) CpxRNTS (25) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (26) CpxRNTS (27) IntTrsBoundProof [UPPER BOUND(ID), 530 ms] (28) CpxRNTS (29) IntTrsBoundProof [UPPER BOUND(ID), 199 ms] (30) CpxRNTS (31) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (32) CpxRNTS (33) IntTrsBoundProof [UPPER BOUND(ID), 336 ms] (34) CpxRNTS (35) IntTrsBoundProof [UPPER BOUND(ID), 137 ms] (36) CpxRNTS (37) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (38) CpxRNTS (39) IntTrsBoundProof [UPPER BOUND(ID), 193 ms] (40) CpxRNTS (41) IntTrsBoundProof [UPPER BOUND(ID), 107 ms] (42) CpxRNTS (43) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (44) CpxRNTS (45) IntTrsBoundProof [UPPER BOUND(ID), 423 ms] (46) CpxRNTS (47) IntTrsBoundProof [UPPER BOUND(ID), 165 ms] (48) CpxRNTS (49) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (50) CpxRNTS (51) IntTrsBoundProof [UPPER BOUND(ID), 959 ms] (52) CpxRNTS (53) IntTrsBoundProof [UPPER BOUND(ID), 612 ms] (54) CpxRNTS (55) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (56) CpxRNTS (57) IntTrsBoundProof [UPPER BOUND(ID), 360 ms] (58) CpxRNTS (59) IntTrsBoundProof [UPPER BOUND(ID), 124 ms] (60) CpxRNTS (61) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (62) CpxRNTS (63) IntTrsBoundProof [UPPER BOUND(ID), 139 ms] (64) CpxRNTS (65) IntTrsBoundProof [UPPER BOUND(ID), 53 ms] (66) CpxRNTS (67) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (68) CpxRNTS (69) IntTrsBoundProof [UPPER BOUND(ID), 6649 ms] (70) CpxRNTS (71) IntTrsBoundProof [UPPER BOUND(ID), 547 ms] (72) CpxRNTS (73) CompletionProof [UPPER BOUND(ID), 41 ms] (74) CpxTypedWeightedCompleteTrs (75) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 11 ms] (76) CpxRNTS (77) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms] (78) CdtProblem (79) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (80) CdtProblem (81) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (82) CdtProblem (83) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (84) CdtProblem (85) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 175 ms] (86) CdtProblem (87) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (88) CdtProblem (89) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (90) CdtProblem (91) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (92) CdtProblem (93) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (94) CdtProblem (95) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (96) CdtProblem (97) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (98) CdtProblem (99) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (100) CdtProblem (101) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (102) CdtProblem (103) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (104) CdtProblem (105) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (106) CdtProblem (107) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (108) CdtProblem (109) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (110) CdtProblem (111) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (112) CdtProblem (113) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 33 ms] (114) CdtProblem (115) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 37 ms] (116) CdtProblem (117) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (118) CdtProblem (119) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (120) CdtProblem (121) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 36 ms] (122) CdtProblem (123) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (124) CdtProblem (125) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (126) CdtProblem (127) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 43 ms] (128) CdtProblem (129) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (130) CdtProblem (131) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (132) CdtProblem (133) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 42 ms] (134) CdtProblem (135) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (136) CdtProblem (137) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (138) CdtProblem (139) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (140) CdtProblem (141) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (142) CdtProblem (143) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (144) CdtProblem (145) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (146) CdtProblem (147) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (148) CdtProblem (149) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (150) CdtProblem (151) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (152) CdtProblem (153) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (154) CdtProblem (155) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (156) CdtProblem (157) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (158) CdtProblem (159) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (160) CdtProblem (161) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (162) CdtProblem (163) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (164) CdtProblem (165) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (166) CdtProblem (167) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (168) CdtProblem (169) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (170) CdtProblem (171) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (172) CdtProblem (173) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (174) CdtProblem (175) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (176) CdtProblem (177) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (178) CdtProblem (179) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 41 ms] (180) CdtProblem (181) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (182) CdtProblem (183) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (184) CdtProblem (185) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (186) CdtProblem (187) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 55 ms] (188) CdtProblem (189) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 64 ms] (190) CdtProblem (191) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (192) CdtProblem (193) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (194) CdtProblem (195) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (196) CdtProblem (197) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 51 ms] (198) CdtProblem (199) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (200) CdtProblem (201) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (202) CdtProblem (203) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 60 ms] (204) CdtProblem (205) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (206) CdtProblem (207) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (208) CdtProblem (209) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (210) CdtProblem (211) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 100 ms] (212) CdtProblem (213) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (214) CdtProblem (215) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (216) CdtProblem (217) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (218) CdtProblem (219) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (220) CdtProblem (221) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (222) CdtProblem (223) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (224) CdtProblem (225) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 92 ms] (226) CdtProblem (227) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (228) CdtProblem (229) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (230) CdtProblem (231) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (232) CdtProblem (233) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (234) CdtProblem (235) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (236) CdtProblem (237) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (238) CdtProblem (239) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (240) CdtProblem (241) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (242) CdtProblem (243) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (244) CdtProblem (245) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (246) CdtProblem (247) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (248) CdtProblem (249) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (250) CdtProblem (251) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (252) CdtProblem (253) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (254) CdtProblem (255) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 126 ms] (256) CdtProblem (257) CdtNarrowingProof [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) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 145 ms] (266) CdtProblem (267) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (268) CdtProblem (269) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (270) CdtProblem (271) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 124 ms] (272) CdtProblem (273) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (274) CdtProblem (275) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (276) CdtProblem (277) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (278) CdtProblem (279) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (280) CdtProblem (281) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (282) CdtProblem (283) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 147 ms] (284) CdtProblem (285) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 135 ms] (286) CdtProblem (287) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (288) CdtProblem (289) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (290) CdtProblem (291) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (292) CdtProblem (293) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 146 ms] (294) CdtProblem (295) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (296) CdtProblem (297) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (298) CdtProblem (299) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 164 ms] (300) CdtProblem (301) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (302) CdtProblem (303) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (304) CdtProblem (305) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (306) CdtProblem (307) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (308) CdtProblem (309) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (310) CdtProblem (311) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (312) CdtProblem ---------------------------------------- (0) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: eq(0, 0) -> true eq(0, s(y)) -> false eq(s(x), 0) -> false eq(s(x), s(y)) -> eq(x, y) lt(0, s(y)) -> true lt(x, 0) -> false lt(s(x), s(y)) -> lt(x, y) bin2s(nil) -> 0 bin2s(cons(x, xs)) -> bin2ss(x, xs) bin2ss(x, nil) -> x bin2ss(x, cons(0, xs)) -> bin2ss(double(x), xs) bin2ss(x, cons(1, xs)) -> bin2ss(s(double(x)), xs) half(0) -> 0 half(s(0)) -> 0 half(s(s(x))) -> s(half(x)) log(0) -> 0 log(s(0)) -> 0 log(s(s(x))) -> s(log(half(s(s(x))))) more(nil) -> nil more(cons(xs, ys)) -> cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys))) s2bin(x) -> s2bin1(x, 0, cons(nil, nil)) s2bin1(x, y, lists) -> if1(lt(y, log(x)), x, y, lists) if1(true, x, y, lists) -> s2bin1(x, s(y), more(lists)) if1(false, x, y, lists) -> s2bin2(x, lists) s2bin2(x, nil) -> bug_list_not s2bin2(x, cons(xs, ys)) -> if2(eq(x, bin2s(xs)), x, xs, ys) if2(true, x, xs, ys) -> xs if2(false, x, xs, ys) -> s2bin2(x, ys) 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: eq(0', 0') -> true eq(0', s(y)) -> false eq(s(x), 0') -> false eq(s(x), s(y)) -> eq(x, y) lt(0', s(y)) -> true lt(x, 0') -> false lt(s(x), s(y)) -> lt(x, y) bin2s(nil) -> 0' bin2s(cons(x, xs)) -> bin2ss(x, xs) bin2ss(x, nil) -> x bin2ss(x, cons(0', xs)) -> bin2ss(double(x), xs) bin2ss(x, cons(1', xs)) -> bin2ss(s(double(x)), xs) half(0') -> 0' half(s(0')) -> 0' half(s(s(x))) -> s(half(x)) log(0') -> 0' log(s(0')) -> 0' log(s(s(x))) -> s(log(half(s(s(x))))) more(nil) -> nil more(cons(xs, ys)) -> cons(cons(0', xs), cons(cons(1', xs), cons(xs, ys))) s2bin(x) -> s2bin1(x, 0', cons(nil, nil)) s2bin1(x, y, lists) -> if1(lt(y, log(x)), x, y, lists) if1(true, x, y, lists) -> s2bin1(x, s(y), more(lists)) if1(false, x, y, lists) -> s2bin2(x, lists) s2bin2(x, nil) -> bug_list_not s2bin2(x, cons(xs, ys)) -> if2(eq(x, bin2s(xs)), x, xs, ys) if2(true, x, xs, ys) -> xs if2(false, x, xs, ys) -> s2bin2(x, ys) S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (3) RelTrsToTrsProof (UPPER BOUND(ID)) transformed relative TRS to TRS ---------------------------------------- (4) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: eq(0, 0) -> true eq(0, s(y)) -> false eq(s(x), 0) -> false eq(s(x), s(y)) -> eq(x, y) lt(0, s(y)) -> true lt(x, 0) -> false lt(s(x), s(y)) -> lt(x, y) bin2s(nil) -> 0 bin2s(cons(x, xs)) -> bin2ss(x, xs) bin2ss(x, nil) -> x bin2ss(x, cons(0, xs)) -> bin2ss(double(x), xs) bin2ss(x, cons(1, xs)) -> bin2ss(s(double(x)), xs) half(0) -> 0 half(s(0)) -> 0 half(s(s(x))) -> s(half(x)) log(0) -> 0 log(s(0)) -> 0 log(s(s(x))) -> s(log(half(s(s(x))))) more(nil) -> nil more(cons(xs, ys)) -> cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys))) s2bin(x) -> s2bin1(x, 0, cons(nil, nil)) s2bin1(x, y, lists) -> if1(lt(y, log(x)), x, y, lists) if1(true, x, y, lists) -> s2bin1(x, s(y), more(lists)) if1(false, x, y, lists) -> s2bin2(x, lists) s2bin2(x, nil) -> bug_list_not s2bin2(x, cons(xs, ys)) -> if2(eq(x, bin2s(xs)), x, xs, ys) if2(true, x, xs, ys) -> xs if2(false, x, xs, ys) -> s2bin2(x, ys) S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (5) RelTrsToWeightedTrsProof (UPPER BOUND(ID)) Transformed relative TRS to weighted TRS ---------------------------------------- (6) Obligation: The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: eq(0, 0) -> true [1] eq(0, s(y)) -> false [1] eq(s(x), 0) -> false [1] eq(s(x), s(y)) -> eq(x, y) [1] lt(0, s(y)) -> true [1] lt(x, 0) -> false [1] lt(s(x), s(y)) -> lt(x, y) [1] bin2s(nil) -> 0 [1] bin2s(cons(x, xs)) -> bin2ss(x, xs) [1] bin2ss(x, nil) -> x [1] bin2ss(x, cons(0, xs)) -> bin2ss(double(x), xs) [1] bin2ss(x, cons(1, xs)) -> bin2ss(s(double(x)), xs) [1] half(0) -> 0 [1] half(s(0)) -> 0 [1] half(s(s(x))) -> s(half(x)) [1] log(0) -> 0 [1] log(s(0)) -> 0 [1] log(s(s(x))) -> s(log(half(s(s(x))))) [1] more(nil) -> nil [1] more(cons(xs, ys)) -> cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys))) [1] s2bin(x) -> s2bin1(x, 0, cons(nil, nil)) [1] s2bin1(x, y, lists) -> if1(lt(y, log(x)), x, y, lists) [1] if1(true, x, y, lists) -> s2bin1(x, s(y), more(lists)) [1] if1(false, x, y, lists) -> s2bin2(x, lists) [1] s2bin2(x, nil) -> bug_list_not [1] s2bin2(x, cons(xs, ys)) -> if2(eq(x, bin2s(xs)), x, xs, ys) [1] if2(true, x, xs, ys) -> xs [1] if2(false, x, xs, ys) -> s2bin2(x, ys) [1] Rewrite Strategy: INNERMOST ---------------------------------------- (7) TypeInferenceProof (BOTH BOUNDS(ID, ID)) Infered types. ---------------------------------------- (8) Obligation: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: eq(0, 0) -> true [1] eq(0, s(y)) -> false [1] eq(s(x), 0) -> false [1] eq(s(x), s(y)) -> eq(x, y) [1] lt(0, s(y)) -> true [1] lt(x, 0) -> false [1] lt(s(x), s(y)) -> lt(x, y) [1] bin2s(nil) -> 0 [1] bin2s(cons(x, xs)) -> bin2ss(x, xs) [1] bin2ss(x, nil) -> x [1] bin2ss(x, cons(0, xs)) -> bin2ss(double(x), xs) [1] bin2ss(x, cons(1, xs)) -> bin2ss(s(double(x)), xs) [1] half(0) -> 0 [1] half(s(0)) -> 0 [1] half(s(s(x))) -> s(half(x)) [1] log(0) -> 0 [1] log(s(0)) -> 0 [1] log(s(s(x))) -> s(log(half(s(s(x))))) [1] more(nil) -> nil [1] more(cons(xs, ys)) -> cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys))) [1] s2bin(x) -> s2bin1(x, 0, cons(nil, nil)) [1] s2bin1(x, y, lists) -> if1(lt(y, log(x)), x, y, lists) [1] if1(true, x, y, lists) -> s2bin1(x, s(y), more(lists)) [1] if1(false, x, y, lists) -> s2bin2(x, lists) [1] s2bin2(x, nil) -> bug_list_not [1] s2bin2(x, cons(xs, ys)) -> if2(eq(x, bin2s(xs)), x, xs, ys) [1] if2(true, x, xs, ys) -> xs [1] if2(false, x, xs, ys) -> s2bin2(x, ys) [1] The TRS has the following type information: eq :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not -> true:false 0 :: 0:s:nil:cons:double:1:bug_list_not true :: true:false s :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not false :: true:false lt :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not -> true:false bin2s :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not nil :: 0:s:nil:cons:double:1:bug_list_not cons :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not bin2ss :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not double :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not 1 :: 0:s:nil:cons:double:1:bug_list_not half :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not log :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not more :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not s2bin :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not s2bin1 :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not if1 :: true:false -> 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not s2bin2 :: 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not bug_list_not :: 0:s:nil:cons:double:1:bug_list_not if2 :: true:false -> 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not -> 0:s:nil:cons:double:1:bug_list_not Rewrite Strategy: INNERMOST ---------------------------------------- (9) CompletionProof (UPPER BOUND(ID)) The transformation into a RNTS is sound, since: (a) The obligation is a constructor system where every type has a constant constructor, (b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols: s2bin_1 s2bin1_3 if1_4 s2bin2_2 if2_4 (c) The following functions are completely defined: more_1 half_1 lt_2 log_1 eq_2 bin2s_1 bin2ss_2 Due to the following rules being added: more(v0) -> null_more [0] half(v0) -> null_half [0] lt(v0, v1) -> null_lt [0] log(v0) -> null_log [0] eq(v0, v1) -> null_eq [0] bin2s(v0) -> null_bin2s [0] bin2ss(v0, v1) -> null_bin2ss [0] And the following fresh constants: null_more, null_half, null_lt, null_log, null_eq, null_bin2s, null_bin2ss ---------------------------------------- (10) Obligation: Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: eq(0, 0) -> true [1] eq(0, s(y)) -> false [1] eq(s(x), 0) -> false [1] eq(s(x), s(y)) -> eq(x, y) [1] lt(0, s(y)) -> true [1] lt(x, 0) -> false [1] lt(s(x), s(y)) -> lt(x, y) [1] bin2s(nil) -> 0 [1] bin2s(cons(x, xs)) -> bin2ss(x, xs) [1] bin2ss(x, nil) -> x [1] bin2ss(x, cons(0, xs)) -> bin2ss(double(x), xs) [1] bin2ss(x, cons(1, xs)) -> bin2ss(s(double(x)), xs) [1] half(0) -> 0 [1] half(s(0)) -> 0 [1] half(s(s(x))) -> s(half(x)) [1] log(0) -> 0 [1] log(s(0)) -> 0 [1] log(s(s(x))) -> s(log(half(s(s(x))))) [1] more(nil) -> nil [1] more(cons(xs, ys)) -> cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys))) [1] s2bin(x) -> s2bin1(x, 0, cons(nil, nil)) [1] s2bin1(x, y, lists) -> if1(lt(y, log(x)), x, y, lists) [1] if1(true, x, y, lists) -> s2bin1(x, s(y), more(lists)) [1] if1(false, x, y, lists) -> s2bin2(x, lists) [1] s2bin2(x, nil) -> bug_list_not [1] s2bin2(x, cons(xs, ys)) -> if2(eq(x, bin2s(xs)), x, xs, ys) [1] if2(true, x, xs, ys) -> xs [1] if2(false, x, xs, ys) -> s2bin2(x, ys) [1] more(v0) -> null_more [0] half(v0) -> null_half [0] lt(v0, v1) -> null_lt [0] log(v0) -> null_log [0] eq(v0, v1) -> null_eq [0] bin2s(v0) -> null_bin2s [0] bin2ss(v0, v1) -> null_bin2ss [0] The TRS has the following type information: eq :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> true:false:null_lt:null_eq 0 :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss true :: true:false:null_lt:null_eq s :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss false :: true:false:null_lt:null_eq lt :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> true:false:null_lt:null_eq bin2s :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss nil :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss cons :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss bin2ss :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss double :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss 1 :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss half :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss log :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss more :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss s2bin :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss s2bin1 :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss if1 :: true:false:null_lt:null_eq -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss s2bin2 :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss bug_list_not :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss if2 :: true:false:null_lt:null_eq -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss null_more :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss null_half :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss null_lt :: true:false:null_lt:null_eq null_log :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss null_eq :: true:false:null_lt:null_eq null_bin2s :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss null_bin2ss :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss Rewrite Strategy: INNERMOST ---------------------------------------- (11) NarrowingProof (BOTH BOUNDS(ID, ID)) Narrowed the inner basic terms of all right-hand sides by a single narrowing step. ---------------------------------------- (12) Obligation: Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: eq(0, 0) -> true [1] eq(0, s(y)) -> false [1] eq(s(x), 0) -> false [1] eq(s(x), s(y)) -> eq(x, y) [1] lt(0, s(y)) -> true [1] lt(x, 0) -> false [1] lt(s(x), s(y)) -> lt(x, y) [1] bin2s(nil) -> 0 [1] bin2s(cons(x, xs)) -> bin2ss(x, xs) [1] bin2ss(x, nil) -> x [1] bin2ss(x, cons(0, xs)) -> bin2ss(double(x), xs) [1] bin2ss(x, cons(1, xs)) -> bin2ss(s(double(x)), xs) [1] half(0) -> 0 [1] half(s(0)) -> 0 [1] half(s(s(x))) -> s(half(x)) [1] log(0) -> 0 [1] log(s(0)) -> 0 [1] log(s(s(x))) -> s(log(s(half(x)))) [2] log(s(s(x))) -> s(log(null_half)) [1] more(nil) -> nil [1] more(cons(xs, ys)) -> cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys))) [1] s2bin(x) -> s2bin1(x, 0, cons(nil, nil)) [1] s2bin1(0, y, lists) -> if1(lt(y, 0), 0, y, lists) [2] s2bin1(s(0), y, lists) -> if1(lt(y, 0), s(0), y, lists) [2] s2bin1(s(s(x')), y, lists) -> if1(lt(y, s(log(half(s(s(x')))))), s(s(x')), y, lists) [2] s2bin1(x, y, lists) -> if1(lt(y, null_log), x, y, lists) [1] if1(true, x, y, nil) -> s2bin1(x, s(y), nil) [2] if1(true, x, y, cons(xs', ys')) -> s2bin1(x, s(y), cons(cons(0, xs'), cons(cons(1, xs'), cons(xs', ys')))) [2] if1(true, x, y, lists) -> s2bin1(x, s(y), null_more) [1] if1(false, x, y, lists) -> s2bin2(x, lists) [1] s2bin2(x, nil) -> bug_list_not [1] s2bin2(x, cons(nil, ys)) -> if2(eq(x, 0), x, nil, ys) [2] s2bin2(x, cons(cons(x'', xs''), ys)) -> if2(eq(x, bin2ss(x'', xs'')), x, cons(x'', xs''), ys) [2] s2bin2(x, cons(xs, ys)) -> if2(eq(x, null_bin2s), x, xs, ys) [1] if2(true, x, xs, ys) -> xs [1] if2(false, x, xs, ys) -> s2bin2(x, ys) [1] more(v0) -> null_more [0] half(v0) -> null_half [0] lt(v0, v1) -> null_lt [0] log(v0) -> null_log [0] eq(v0, v1) -> null_eq [0] bin2s(v0) -> null_bin2s [0] bin2ss(v0, v1) -> null_bin2ss [0] The TRS has the following type information: eq :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> true:false:null_lt:null_eq 0 :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss true :: true:false:null_lt:null_eq s :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss false :: true:false:null_lt:null_eq lt :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> true:false:null_lt:null_eq bin2s :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss nil :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss cons :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss bin2ss :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss double :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss 1 :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss half :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss log :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss more :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss s2bin :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss s2bin1 :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss if1 :: true:false:null_lt:null_eq -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss s2bin2 :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss bug_list_not :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss if2 :: true:false:null_lt:null_eq -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss -> 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss null_more :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss null_half :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss null_lt :: true:false:null_lt:null_eq null_log :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss null_eq :: true:false:null_lt:null_eq null_bin2s :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss null_bin2ss :: 0:s:nil:cons:double:1:bug_list_not:null_more:null_half:null_log:null_bin2s:null_bin2ss Rewrite Strategy: INNERMOST ---------------------------------------- (13) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID)) Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction. The constant constructors are abstracted as follows: 0 => 0 true => 2 false => 1 nil => 3 1 => 1 bug_list_not => 2 null_more => 0 null_half => 0 null_lt => 0 null_log => 0 null_eq => 0 null_bin2s => 0 null_bin2ss => 0 ---------------------------------------- (14) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 bin2ss(z, z') -{ 1 }-> x :|: z' = 3, x >= 0, z = x bin2ss(z, z') -{ 1 }-> bin2ss(1 + x, xs) :|: xs >= 0, z' = 1 + 0 + xs, x >= 0, z = x bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + x), xs) :|: xs >= 0, z' = 1 + 1 + xs, x >= 0, z = x bin2ss(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 eq(z, z') -{ 1 }-> eq(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' = 1 + y, y >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: x >= 0, z = 1 + x, z' = 0 eq(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 half(z) -{ 1 }-> 1 + half(x) :|: x >= 0, z = 1 + (1 + x) if1(z, z', z'', z1) -{ 1 }-> s2bin2(x, lists) :|: z' = x, z'' = y, z = 1, x >= 0, y >= 0, lists >= 0, z1 = lists if1(z, z', z'', z1) -{ 2 }-> s2bin1(x, 1 + y, 3) :|: z = 2, z' = x, z'' = y, x >= 0, y >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(x, 1 + y, 0) :|: z = 2, z' = x, z'' = y, x >= 0, y >= 0, lists >= 0, z1 = lists if1(z, z', z'', z1) -{ 2 }-> s2bin1(x, 1 + y, 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' = x, z'' = y, x >= 0, y >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> xs :|: z = 2, xs >= 0, z' = x, ys >= 0, x >= 0, z'' = xs, z1 = ys if2(z, z', z'', z1) -{ 1 }-> s2bin2(x, ys) :|: xs >= 0, z' = x, z = 1, ys >= 0, x >= 0, z'' = xs, z1 = ys log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 log(z) -{ 1 }-> 1 + log(0) :|: x >= 0, z = 1 + (1 + x) log(z) -{ 2 }-> 1 + log(1 + half(x)) :|: x >= 0, z = 1 + (1 + x) lt(z, z') -{ 1 }-> lt(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x lt(z, z') -{ 1 }-> 2 :|: z' = 1 + y, y >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: x >= 0, z = x, z' = 0 lt(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(x, 0, 1 + 3 + 3) :|: x >= 0, z = x s2bin1(z, z', z'') -{ 1 }-> if1(lt(y, 0), x, y, lists) :|: x >= 0, y >= 0, lists >= 0, z'' = lists, z = x, z' = y s2bin1(z, z', z'') -{ 2 }-> if1(lt(y, 0), 0, y, lists) :|: y >= 0, lists >= 0, z'' = lists, z = 0, z' = y s2bin1(z, z', z'') -{ 2 }-> if1(lt(y, 0), 1 + 0, y, lists) :|: z = 1 + 0, y >= 0, lists >= 0, z'' = lists, z' = y s2bin1(z, z', z'') -{ 2 }-> if1(lt(y, 1 + log(half(1 + (1 + x')))), 1 + (1 + x'), y, lists) :|: x' >= 0, y >= 0, lists >= 0, z = 1 + (1 + x'), z'' = lists, z' = y s2bin2(z, z') -{ 2 }-> if2(eq(x, bin2ss(x'', xs'')), x, 1 + x'' + xs'', ys) :|: ys >= 0, x >= 0, xs'' >= 0, x'' >= 0, z = x, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> if2(eq(x, 0), x, xs, ys) :|: xs >= 0, ys >= 0, x >= 0, z' = 1 + xs + ys, z = x s2bin2(z, z') -{ 2 }-> if2(eq(x, 0), x, 3, ys) :|: ys >= 0, x >= 0, z' = 1 + 3 + ys, z = x s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, x >= 0, z = x ---------------------------------------- (15) SimplificationProof (BOTH BOUNDS(ID, ID)) Simplified the RNTS by moving equalities from the constraints into the right-hand sides. ---------------------------------------- (16) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 1 }-> if1(lt(z', 0), z, z', z'') :|: z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 0, z', z'') :|: z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 1 + 0, z', z'') :|: z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> if2(eq(z, 0), z, xs, ys) :|: xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, 0), z, 3, z' - 4) :|: z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 ---------------------------------------- (17) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID)) Found the following analysis order by SCC decomposition: { more } { eq } { lt } { half } { bin2ss } { if2, s2bin2 } { log } { bin2s } { s2bin1, if1 } { s2bin } ---------------------------------------- (18) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 1 }-> if1(lt(z', 0), z, z', z'') :|: z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 0, z', z'') :|: z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 1 + 0, z', z'') :|: z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> if2(eq(z, 0), z, xs, ys) :|: xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, 0), z, 3, z' - 4) :|: z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {more}, {eq}, {lt}, {half}, {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} ---------------------------------------- (19) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (20) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 1 }-> if1(lt(z', 0), z, z', z'') :|: z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 0, z', z'') :|: z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 1 + 0, z', z'') :|: z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> if2(eq(z, 0), z, xs, ys) :|: xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, 0), z, 3, z' - 4) :|: z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {more}, {eq}, {lt}, {half}, {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} ---------------------------------------- (21) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: more after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 3 + 3*z ---------------------------------------- (22) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 1 }-> if1(lt(z', 0), z, z', z'') :|: z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 0, z', z'') :|: z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 1 + 0, z', z'') :|: z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> if2(eq(z, 0), z, xs, ys) :|: xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, 0), z, 3, z' - 4) :|: z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {more}, {eq}, {lt}, {half}, {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: ?, size: O(n^1) [3 + 3*z] ---------------------------------------- (23) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: more after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (24) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 1 }-> if1(lt(z', 0), z, z', z'') :|: z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 0, z', z'') :|: z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 1 + 0, z', z'') :|: z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> if2(eq(z, 0), z, xs, ys) :|: xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, 0), z, 3, z' - 4) :|: z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {eq}, {lt}, {half}, {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] ---------------------------------------- (25) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (26) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 1 }-> if1(lt(z', 0), z, z', z'') :|: z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 0, z', z'') :|: z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 1 + 0, z', z'') :|: z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> if2(eq(z, 0), z, xs, ys) :|: xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, 0), z, 3, z' - 4) :|: z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {eq}, {lt}, {half}, {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] ---------------------------------------- (27) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: eq after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 2 ---------------------------------------- (28) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 1 }-> if1(lt(z', 0), z, z', z'') :|: z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 0, z', z'') :|: z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 1 + 0, z', z'') :|: z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> if2(eq(z, 0), z, xs, ys) :|: xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, 0), z, 3, z' - 4) :|: z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {eq}, {lt}, {half}, {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: ?, size: O(1) [2] ---------------------------------------- (29) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using KoAT for: eq after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 3 + z ---------------------------------------- (30) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 1 }-> if1(lt(z', 0), z, z', z'') :|: z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 0, z', z'') :|: z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 1 + 0, z', z'') :|: z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> if2(eq(z, 0), z, xs, ys) :|: xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, 0), z, 3, z' - 4) :|: z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {lt}, {half}, {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] ---------------------------------------- (31) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (32) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 1 }-> if1(lt(z', 0), z, z', z'') :|: z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 0, z', z'') :|: z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 1 + 0, z', z'') :|: z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 5 + z }-> if2(s', z, 3, z' - 4) :|: s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 4 + z }-> if2(s'', z, xs, ys) :|: s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {lt}, {half}, {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] ---------------------------------------- (33) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: lt after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 2 ---------------------------------------- (34) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 1 }-> if1(lt(z', 0), z, z', z'') :|: z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 0, z', z'') :|: z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 1 + 0, z', z'') :|: z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 5 + z }-> if2(s', z, 3, z' - 4) :|: s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 4 + z }-> if2(s'', z, xs, ys) :|: s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {lt}, {half}, {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: ?, size: O(1) [2] ---------------------------------------- (35) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using KoAT for: lt after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 2 + z' ---------------------------------------- (36) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 1 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 1 }-> if1(lt(z', 0), z, z', z'') :|: z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 0, z', z'') :|: z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 0), 1 + 0, z', z'') :|: z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 5 + z }-> if2(s', z, 3, z' - 4) :|: s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 4 + z }-> if2(s'', z, xs, ys) :|: s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {half}, {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] ---------------------------------------- (37) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (38) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 5 + z }-> if2(s', z, 3, z' - 4) :|: s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 4 + z }-> if2(s'', z, xs, ys) :|: s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {half}, {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] ---------------------------------------- (39) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: half after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z ---------------------------------------- (40) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 5 + z }-> if2(s', z, 3, z' - 4) :|: s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 4 + z }-> if2(s'', z, xs, ys) :|: s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {half}, {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: ?, size: O(n^1) [z] ---------------------------------------- (41) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: half after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 2 + z ---------------------------------------- (42) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 }-> 1 + half(z - 2) :|: z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 }-> 1 + log(1 + half(z - 2)) :|: z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 2 }-> if1(lt(z', 1 + log(half(1 + (1 + (z - 2))))), 1 + (1 + (z - 2)), z', z'') :|: z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 5 + z }-> if2(s', z, 3, z' - 4) :|: s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 4 + z }-> if2(s'', z, xs, ys) :|: s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] ---------------------------------------- (43) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (44) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 + z }-> 1 + log(1 + s6) :|: s6 >= 0, s6 <= z - 2, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 + z }-> if1(lt(z', 1 + log(s7)), 1 + (1 + (z - 2)), z', z'') :|: s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 5 + z }-> if2(s', z, 3, z' - 4) :|: s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 4 + z }-> if2(s'', z, xs, ys) :|: s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] ---------------------------------------- (45) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: bin2ss after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z + z' ---------------------------------------- (46) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 + z }-> 1 + log(1 + s6) :|: s6 >= 0, s6 <= z - 2, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 + z }-> if1(lt(z', 1 + log(s7)), 1 + (1 + (z - 2)), z', z'') :|: s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 5 + z }-> if2(s', z, 3, z' - 4) :|: s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 4 + z }-> if2(s'', z, xs, ys) :|: s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {bin2ss}, {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: ?, size: O(n^1) [z + z'] ---------------------------------------- (47) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: bin2ss after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z' ---------------------------------------- (48) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + z, z' - 1) :|: z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + z), z' - 2) :|: z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 + z }-> 1 + log(1 + s6) :|: s6 >= 0, s6 <= z - 2, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 + z }-> if1(lt(z', 1 + log(s7)), 1 + (1 + (z - 2)), z', z'') :|: s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 5 + z }-> if2(s', z, 3, z' - 4) :|: s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 4 + z }-> if2(s'', z, xs, ys) :|: s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 2 }-> if2(eq(z, bin2ss(x'', xs'')), z, 1 + x'' + xs'', ys) :|: ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] ---------------------------------------- (49) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (50) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 2 + xs }-> s8 :|: s8 >= 0, s8 <= x + xs, z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ z' }-> s10 :|: s10 >= 0, s10 <= 1 + (1 + z) + (z' - 2), z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 1 + z' }-> s9 :|: s9 >= 0, s9 <= 1 + z + (z' - 1), z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 + z }-> 1 + log(1 + s6) :|: s6 >= 0, s6 <= z - 2, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 + z }-> if1(lt(z', 1 + log(s7)), 1 + (1 + (z - 2)), z', z'') :|: s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 5 + z }-> if2(s', z, 3, z' - 4) :|: s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 4 + z }-> if2(s'', z, xs, ys) :|: s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 6 + xs'' + z }-> if2(s12, z, 1 + x'' + xs'', ys) :|: s11 >= 0, s11 <= x'' + xs'', s12 >= 0, s12 <= 2, ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] ---------------------------------------- (51) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: if2 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z'' + z1 Computed SIZE bound using KoAT for: s2bin2 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z' ---------------------------------------- (52) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 2 + xs }-> s8 :|: s8 >= 0, s8 <= x + xs, z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ z' }-> s10 :|: s10 >= 0, s10 <= 1 + (1 + z) + (z' - 2), z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 1 + z' }-> s9 :|: s9 >= 0, s9 <= 1 + z + (z' - 1), z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 + z }-> 1 + log(1 + s6) :|: s6 >= 0, s6 <= z - 2, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 + z }-> if1(lt(z', 1 + log(s7)), 1 + (1 + (z - 2)), z', z'') :|: s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 5 + z }-> if2(s', z, 3, z' - 4) :|: s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 4 + z }-> if2(s'', z, xs, ys) :|: s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 6 + xs'' + z }-> if2(s12, z, 1 + x'' + xs'', ys) :|: s11 >= 0, s11 <= x'' + xs'', s12 >= 0, s12 <= 2, ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {if2,s2bin2}, {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] if2: runtime: ?, size: O(n^1) [z'' + z1] s2bin2: runtime: ?, size: O(n^1) [z'] ---------------------------------------- (53) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: if2 after applying outer abstraction to obtain an ITS, resulting in: O(n^2) with polynomial bound: 35 + 6*z' + 2*z'*z1 + 13*z1 + z1^2 Computed RUNTIME bound using KoAT for: s2bin2 after applying outer abstraction to obtain an ITS, resulting in: O(n^2) with polynomial bound: 85 + 14*z + 6*z*z' + 32*z' + 3*z'^2 ---------------------------------------- (54) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 2 + xs }-> s8 :|: s8 >= 0, s8 <= x + xs, z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ z' }-> s10 :|: s10 >= 0, s10 <= 1 + (1 + z) + (z' - 2), z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 1 + z' }-> s9 :|: s9 >= 0, s9 <= 1 + z + (z' - 1), z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> s2bin2(z', z1) :|: z'' >= 0, z = 1, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 + z }-> 1 + log(1 + s6) :|: s6 >= 0, s6 <= z - 2, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 + z }-> if1(lt(z', 1 + log(s7)), 1 + (1 + (z - 2)), z', z'') :|: s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 5 + z }-> if2(s', z, 3, z' - 4) :|: s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 4 + z }-> if2(s'', z, xs, ys) :|: s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 6 + xs'' + z }-> if2(s12, z, 1 + x'' + xs'', ys) :|: s11 >= 0, s11 <= x'' + xs'', s12 >= 0, s12 <= 2, ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] if2: runtime: O(n^2) [35 + 6*z' + 2*z'*z1 + 13*z1 + z1^2], size: O(n^1) [z'' + z1] s2bin2: runtime: O(n^2) [85 + 14*z + 6*z*z' + 32*z' + 3*z'^2], size: O(n^1) [z'] ---------------------------------------- (55) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (56) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 2 + xs }-> s8 :|: s8 >= 0, s8 <= x + xs, z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ z' }-> s10 :|: s10 >= 0, s10 <= 1 + (1 + z) + (z' - 2), z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 1 + z' }-> s9 :|: s9 >= 0, s9 <= 1 + z + (z' - 1), z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s13 :|: s13 >= 0, s13 <= z1, z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s17 :|: s17 >= 0, s17 <= z1, z'' >= 0, z = 1, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 + z }-> 1 + log(1 + s6) :|: s6 >= 0, s6 <= z - 2, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 + z }-> if1(lt(z', 1 + log(s7)), 1 + (1 + (z - 2)), z', z'') :|: s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 4 + -1*z + 2*z*z' + 5*z' + z'^2 }-> s14 :|: s14 >= 0, s14 <= 3 + (z' - 4), s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 41 + xs'' + 13*ys + 2*ys*z + ys^2 + 7*z }-> s15 :|: s15 >= 0, s15 <= 1 + x'' + xs'' + ys, s11 >= 0, s11 <= x'' + xs'', s12 >= 0, s12 <= 2, ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 39 + 13*ys + 2*ys*z + ys^2 + 7*z }-> s16 :|: s16 >= 0, s16 <= xs + ys, s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] if2: runtime: O(n^2) [35 + 6*z' + 2*z'*z1 + 13*z1 + z1^2], size: O(n^1) [z'' + z1] s2bin2: runtime: O(n^2) [85 + 14*z + 6*z*z' + 32*z' + 3*z'^2], size: O(n^1) [z'] ---------------------------------------- (57) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: log after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z ---------------------------------------- (58) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 2 + xs }-> s8 :|: s8 >= 0, s8 <= x + xs, z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ z' }-> s10 :|: s10 >= 0, s10 <= 1 + (1 + z) + (z' - 2), z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 1 + z' }-> s9 :|: s9 >= 0, s9 <= 1 + z + (z' - 1), z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s13 :|: s13 >= 0, s13 <= z1, z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s17 :|: s17 >= 0, s17 <= z1, z'' >= 0, z = 1, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 + z }-> 1 + log(1 + s6) :|: s6 >= 0, s6 <= z - 2, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 + z }-> if1(lt(z', 1 + log(s7)), 1 + (1 + (z - 2)), z', z'') :|: s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 4 + -1*z + 2*z*z' + 5*z' + z'^2 }-> s14 :|: s14 >= 0, s14 <= 3 + (z' - 4), s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 41 + xs'' + 13*ys + 2*ys*z + ys^2 + 7*z }-> s15 :|: s15 >= 0, s15 <= 1 + x'' + xs'' + ys, s11 >= 0, s11 <= x'' + xs'', s12 >= 0, s12 <= 2, ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 39 + 13*ys + 2*ys*z + ys^2 + 7*z }-> s16 :|: s16 >= 0, s16 <= xs + ys, s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {log}, {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] if2: runtime: O(n^2) [35 + 6*z' + 2*z'*z1 + 13*z1 + z1^2], size: O(n^1) [z'' + z1] s2bin2: runtime: O(n^2) [85 + 14*z + 6*z*z' + 32*z' + 3*z'^2], size: O(n^1) [z'] log: runtime: ?, size: O(n^1) [z] ---------------------------------------- (59) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using KoAT for: log after applying outer abstraction to obtain an ITS, resulting in: O(n^2) with polynomial bound: 2 + 3*z + z^2 ---------------------------------------- (60) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 2 + xs }-> s8 :|: s8 >= 0, s8 <= x + xs, z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ z' }-> s10 :|: s10 >= 0, s10 <= 1 + (1 + z) + (z' - 2), z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 1 + z' }-> s9 :|: s9 >= 0, s9 <= 1 + z + (z' - 1), z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s13 :|: s13 >= 0, s13 <= z1, z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s17 :|: s17 >= 0, s17 <= z1, z'' >= 0, z = 1, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 1 }-> 1 + log(0) :|: z - 2 >= 0 log(z) -{ 2 + z }-> 1 + log(1 + s6) :|: s6 >= 0, s6 <= z - 2, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 + z }-> if1(lt(z', 1 + log(s7)), 1 + (1 + (z - 2)), z', z'') :|: s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 4 + -1*z + 2*z*z' + 5*z' + z'^2 }-> s14 :|: s14 >= 0, s14 <= 3 + (z' - 4), s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 41 + xs'' + 13*ys + 2*ys*z + ys^2 + 7*z }-> s15 :|: s15 >= 0, s15 <= 1 + x'' + xs'' + ys, s11 >= 0, s11 <= x'' + xs'', s12 >= 0, s12 <= 2, ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 39 + 13*ys + 2*ys*z + ys^2 + 7*z }-> s16 :|: s16 >= 0, s16 <= xs + ys, s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] if2: runtime: O(n^2) [35 + 6*z' + 2*z'*z1 + 13*z1 + z1^2], size: O(n^1) [z'' + z1] s2bin2: runtime: O(n^2) [85 + 14*z + 6*z*z' + 32*z' + 3*z'^2], size: O(n^1) [z'] log: runtime: O(n^2) [2 + 3*z + z^2], size: O(n^1) [z] ---------------------------------------- (61) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (62) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 2 + xs }-> s8 :|: s8 >= 0, s8 <= x + xs, z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ z' }-> s10 :|: s10 >= 0, s10 <= 1 + (1 + z) + (z' - 2), z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 1 + z' }-> s9 :|: s9 >= 0, s9 <= 1 + z + (z' - 1), z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s13 :|: s13 >= 0, s13 <= z1, z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s17 :|: s17 >= 0, s17 <= z1, z'' >= 0, z = 1, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 8 + 5*s6 + s6^2 + z }-> 1 + s18 :|: s18 >= 0, s18 <= 1 + s6, s6 >= 0, s6 <= z - 2, z - 2 >= 0 log(z) -{ 3 }-> 1 + s19 :|: s19 >= 0, s19 <= 0, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 9 + s20 + 3*s7 + s7^2 + z }-> if1(s21, 1 + (1 + (z - 2)), z', z'') :|: s20 >= 0, s20 <= s7, s21 >= 0, s21 <= 2, s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 4 + -1*z + 2*z*z' + 5*z' + z'^2 }-> s14 :|: s14 >= 0, s14 <= 3 + (z' - 4), s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 41 + xs'' + 13*ys + 2*ys*z + ys^2 + 7*z }-> s15 :|: s15 >= 0, s15 <= 1 + x'' + xs'' + ys, s11 >= 0, s11 <= x'' + xs'', s12 >= 0, s12 <= 2, ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 39 + 13*ys + 2*ys*z + ys^2 + 7*z }-> s16 :|: s16 >= 0, s16 <= xs + ys, s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] if2: runtime: O(n^2) [35 + 6*z' + 2*z'*z1 + 13*z1 + z1^2], size: O(n^1) [z'' + z1] s2bin2: runtime: O(n^2) [85 + 14*z + 6*z*z' + 32*z' + 3*z'^2], size: O(n^1) [z'] log: runtime: O(n^2) [2 + 3*z + z^2], size: O(n^1) [z] ---------------------------------------- (63) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: bin2s after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z ---------------------------------------- (64) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 2 + xs }-> s8 :|: s8 >= 0, s8 <= x + xs, z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ z' }-> s10 :|: s10 >= 0, s10 <= 1 + (1 + z) + (z' - 2), z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 1 + z' }-> s9 :|: s9 >= 0, s9 <= 1 + z + (z' - 1), z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s13 :|: s13 >= 0, s13 <= z1, z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s17 :|: s17 >= 0, s17 <= z1, z'' >= 0, z = 1, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 8 + 5*s6 + s6^2 + z }-> 1 + s18 :|: s18 >= 0, s18 <= 1 + s6, s6 >= 0, s6 <= z - 2, z - 2 >= 0 log(z) -{ 3 }-> 1 + s19 :|: s19 >= 0, s19 <= 0, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 9 + s20 + 3*s7 + s7^2 + z }-> if1(s21, 1 + (1 + (z - 2)), z', z'') :|: s20 >= 0, s20 <= s7, s21 >= 0, s21 <= 2, s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 4 + -1*z + 2*z*z' + 5*z' + z'^2 }-> s14 :|: s14 >= 0, s14 <= 3 + (z' - 4), s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 41 + xs'' + 13*ys + 2*ys*z + ys^2 + 7*z }-> s15 :|: s15 >= 0, s15 <= 1 + x'' + xs'' + ys, s11 >= 0, s11 <= x'' + xs'', s12 >= 0, s12 <= 2, ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 39 + 13*ys + 2*ys*z + ys^2 + 7*z }-> s16 :|: s16 >= 0, s16 <= xs + ys, s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {bin2s}, {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] if2: runtime: O(n^2) [35 + 6*z' + 2*z'*z1 + 13*z1 + z1^2], size: O(n^1) [z'' + z1] s2bin2: runtime: O(n^2) [85 + 14*z + 6*z*z' + 32*z' + 3*z'^2], size: O(n^1) [z'] log: runtime: O(n^2) [2 + 3*z + z^2], size: O(n^1) [z] bin2s: runtime: ?, size: O(n^1) [z] ---------------------------------------- (65) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: bin2s after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z ---------------------------------------- (66) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 2 + xs }-> s8 :|: s8 >= 0, s8 <= x + xs, z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ z' }-> s10 :|: s10 >= 0, s10 <= 1 + (1 + z) + (z' - 2), z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 1 + z' }-> s9 :|: s9 >= 0, s9 <= 1 + z + (z' - 1), z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s13 :|: s13 >= 0, s13 <= z1, z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s17 :|: s17 >= 0, s17 <= z1, z'' >= 0, z = 1, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 8 + 5*s6 + s6^2 + z }-> 1 + s18 :|: s18 >= 0, s18 <= 1 + s6, s6 >= 0, s6 <= z - 2, z - 2 >= 0 log(z) -{ 3 }-> 1 + s19 :|: s19 >= 0, s19 <= 0, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 9 + s20 + 3*s7 + s7^2 + z }-> if1(s21, 1 + (1 + (z - 2)), z', z'') :|: s20 >= 0, s20 <= s7, s21 >= 0, s21 <= 2, s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 4 + -1*z + 2*z*z' + 5*z' + z'^2 }-> s14 :|: s14 >= 0, s14 <= 3 + (z' - 4), s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 41 + xs'' + 13*ys + 2*ys*z + ys^2 + 7*z }-> s15 :|: s15 >= 0, s15 <= 1 + x'' + xs'' + ys, s11 >= 0, s11 <= x'' + xs'', s12 >= 0, s12 <= 2, ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 39 + 13*ys + 2*ys*z + ys^2 + 7*z }-> s16 :|: s16 >= 0, s16 <= xs + ys, s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] if2: runtime: O(n^2) [35 + 6*z' + 2*z'*z1 + 13*z1 + z1^2], size: O(n^1) [z'' + z1] s2bin2: runtime: O(n^2) [85 + 14*z + 6*z*z' + 32*z' + 3*z'^2], size: O(n^1) [z'] log: runtime: O(n^2) [2 + 3*z + z^2], size: O(n^1) [z] bin2s: runtime: O(n^1) [1 + z], size: O(n^1) [z] ---------------------------------------- (67) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (68) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 2 + xs }-> s8 :|: s8 >= 0, s8 <= x + xs, z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ z' }-> s10 :|: s10 >= 0, s10 <= 1 + (1 + z) + (z' - 2), z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 1 + z' }-> s9 :|: s9 >= 0, s9 <= 1 + z + (z' - 1), z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s13 :|: s13 >= 0, s13 <= z1, z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s17 :|: s17 >= 0, s17 <= z1, z'' >= 0, z = 1, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 8 + 5*s6 + s6^2 + z }-> 1 + s18 :|: s18 >= 0, s18 <= 1 + s6, s6 >= 0, s6 <= z - 2, z - 2 >= 0 log(z) -{ 3 }-> 1 + s19 :|: s19 >= 0, s19 <= 0, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 9 + s20 + 3*s7 + s7^2 + z }-> if1(s21, 1 + (1 + (z - 2)), z', z'') :|: s20 >= 0, s20 <= s7, s21 >= 0, s21 <= 2, s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 4 + -1*z + 2*z*z' + 5*z' + z'^2 }-> s14 :|: s14 >= 0, s14 <= 3 + (z' - 4), s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 41 + xs'' + 13*ys + 2*ys*z + ys^2 + 7*z }-> s15 :|: s15 >= 0, s15 <= 1 + x'' + xs'' + ys, s11 >= 0, s11 <= x'' + xs'', s12 >= 0, s12 <= 2, ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 39 + 13*ys + 2*ys*z + ys^2 + 7*z }-> s16 :|: s16 >= 0, s16 <= xs + ys, s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] if2: runtime: O(n^2) [35 + 6*z' + 2*z'*z1 + 13*z1 + z1^2], size: O(n^1) [z'' + z1] s2bin2: runtime: O(n^2) [85 + 14*z + 6*z*z' + 32*z' + 3*z'^2], size: O(n^1) [z'] log: runtime: O(n^2) [2 + 3*z + z^2], size: O(n^1) [z] bin2s: runtime: O(n^1) [1 + z], size: O(n^1) [z] ---------------------------------------- (69) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: s2bin1 after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? Computed SIZE bound using CoFloCo for: if1 after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (70) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 2 + xs }-> s8 :|: s8 >= 0, s8 <= x + xs, z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ z' }-> s10 :|: s10 >= 0, s10 <= 1 + (1 + z) + (z' - 2), z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 1 + z' }-> s9 :|: s9 >= 0, s9 <= 1 + z + (z' - 1), z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s13 :|: s13 >= 0, s13 <= z1, z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s17 :|: s17 >= 0, s17 <= z1, z'' >= 0, z = 1, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 8 + 5*s6 + s6^2 + z }-> 1 + s18 :|: s18 >= 0, s18 <= 1 + s6, s6 >= 0, s6 <= z - 2, z - 2 >= 0 log(z) -{ 3 }-> 1 + s19 :|: s19 >= 0, s19 <= 0, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 9 + s20 + 3*s7 + s7^2 + z }-> if1(s21, 1 + (1 + (z - 2)), z', z'') :|: s20 >= 0, s20 <= s7, s21 >= 0, s21 <= 2, s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 4 + -1*z + 2*z*z' + 5*z' + z'^2 }-> s14 :|: s14 >= 0, s14 <= 3 + (z' - 4), s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 41 + xs'' + 13*ys + 2*ys*z + ys^2 + 7*z }-> s15 :|: s15 >= 0, s15 <= 1 + x'' + xs'' + ys, s11 >= 0, s11 <= x'' + xs'', s12 >= 0, s12 <= 2, ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 39 + 13*ys + 2*ys*z + ys^2 + 7*z }-> s16 :|: s16 >= 0, s16 <= xs + ys, s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] if2: runtime: O(n^2) [35 + 6*z' + 2*z'*z1 + 13*z1 + z1^2], size: O(n^1) [z'' + z1] s2bin2: runtime: O(n^2) [85 + 14*z + 6*z*z' + 32*z' + 3*z'^2], size: O(n^1) [z'] log: runtime: O(n^2) [2 + 3*z + z^2], size: O(n^1) [z] bin2s: runtime: O(n^1) [1 + z], size: O(n^1) [z] s2bin1: runtime: ?, size: INF if1: runtime: ?, size: INF ---------------------------------------- (71) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: s2bin1 after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (72) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 2 + xs }-> s8 :|: s8 >= 0, s8 <= x + xs, z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: z >= 0 bin2ss(z, z') -{ z' }-> s10 :|: s10 >= 0, s10 <= 1 + (1 + z) + (z' - 2), z' - 2 >= 0, z >= 0 bin2ss(z, z') -{ 1 + z' }-> s9 :|: s9 >= 0, s9 <= 1 + z + (z' - 1), z' - 1 >= 0, z >= 0 bin2ss(z, z') -{ 1 }-> z :|: z' = 3, z >= 0 bin2ss(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 eq(z, z') -{ 3 + z }-> s :|: s >= 0, s <= 2, z - 1 >= 0, z' - 1 >= 0 eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0 eq(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: z >= 0 half(z) -{ 1 + z }-> 1 + s5 :|: s5 >= 0, s5 <= z - 2, z - 2 >= 0 if1(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s13 :|: s13 >= 0, s13 <= z1, z = 1, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 3) :|: z = 2, z' >= 0, z'' >= 0, z1 = 3 if1(z, z', z'', z1) -{ 1 }-> s2bin1(z', 1 + z'', 0) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0 if1(z, z', z'', z1) -{ 2 }-> s2bin1(z', 1 + z'', 1 + (1 + 0 + xs') + (1 + (1 + 1 + xs') + (1 + xs' + ys'))) :|: z = 2, z' >= 0, z'' >= 0, xs' >= 0, ys' >= 0, z1 = 1 + xs' + ys' if2(z, z', z'', z1) -{ 86 + 14*z' + 6*z'*z1 + 32*z1 + 3*z1^2 }-> s17 :|: s17 >= 0, s17 <= z1, z'' >= 0, z = 1, z1 >= 0, z' >= 0 if2(z, z', z'', z1) -{ 1 }-> z'' :|: z = 2, z'' >= 0, z1 >= 0, z' >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: z >= 0 log(z) -{ 8 + 5*s6 + s6^2 + z }-> 1 + s18 :|: s18 >= 0, s18 <= 1 + s6, s6 >= 0, s6 <= z - 2, z - 2 >= 0 log(z) -{ 3 }-> 1 + s19 :|: s19 >= 0, s19 <= 0, z - 2 >= 0 lt(z, z') -{ 2 + z' }-> s1 :|: s1 >= 0, s1 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: z >= 0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(z, 0, 1 + 3 + 3) :|: z >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s2, 0, z', z'') :|: s2 >= 0, s2 <= 2, z' >= 0, z'' >= 0, z = 0 s2bin1(z, z', z'') -{ 9 + s20 + 3*s7 + s7^2 + z }-> if1(s21, 1 + (1 + (z - 2)), z', z'') :|: s20 >= 0, s20 <= s7, s21 >= 0, s21 <= 2, s7 >= 0, s7 <= 1 + (1 + (z - 2)), z - 2 >= 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 4 }-> if1(s3, 1 + 0, z', z'') :|: s3 >= 0, s3 <= 2, z = 1 + 0, z' >= 0, z'' >= 0 s2bin1(z, z', z'') -{ 3 }-> if1(s4, z, z', z'') :|: s4 >= 0, s4 <= 2, z >= 0, z' >= 0, z'' >= 0 s2bin2(z, z') -{ 4 + -1*z + 2*z*z' + 5*z' + z'^2 }-> s14 :|: s14 >= 0, s14 <= 3 + (z' - 4), s' >= 0, s' <= 2, z' - 4 >= 0, z >= 0 s2bin2(z, z') -{ 41 + xs'' + 13*ys + 2*ys*z + ys^2 + 7*z }-> s15 :|: s15 >= 0, s15 <= 1 + x'' + xs'' + ys, s11 >= 0, s11 <= x'' + xs'', s12 >= 0, s12 <= 2, ys >= 0, z >= 0, xs'' >= 0, x'' >= 0, z' = 1 + (1 + x'' + xs'') + ys s2bin2(z, z') -{ 39 + 13*ys + 2*ys*z + ys^2 + 7*z }-> s16 :|: s16 >= 0, s16 <= xs + ys, s'' >= 0, s'' <= 2, xs >= 0, ys >= 0, z >= 0, z' = 1 + xs + ys s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, z >= 0 Function symbols to be analyzed: {s2bin1,if1}, {s2bin} Previous analysis results are: more: runtime: O(1) [1], size: O(n^1) [3 + 3*z] eq: runtime: O(n^1) [3 + z], size: O(1) [2] lt: runtime: O(n^1) [2 + z'], size: O(1) [2] half: runtime: O(n^1) [2 + z], size: O(n^1) [z] bin2ss: runtime: O(n^1) [1 + z'], size: O(n^1) [z + z'] if2: runtime: O(n^2) [35 + 6*z' + 2*z'*z1 + 13*z1 + z1^2], size: O(n^1) [z'' + z1] s2bin2: runtime: O(n^2) [85 + 14*z + 6*z*z' + 32*z' + 3*z'^2], size: O(n^1) [z'] log: runtime: O(n^2) [2 + 3*z + z^2], size: O(n^1) [z] bin2s: runtime: O(n^1) [1 + z], size: O(n^1) [z] s2bin1: runtime: INF, size: INF if1: runtime: ?, size: INF ---------------------------------------- (73) 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: eq(v0, v1) -> null_eq [0] lt(v0, v1) -> null_lt [0] bin2s(v0) -> null_bin2s [0] bin2ss(v0, v1) -> null_bin2ss [0] half(v0) -> null_half [0] log(v0) -> null_log [0] more(v0) -> null_more [0] s2bin2(v0, v1) -> null_s2bin2 [0] if1(v0, v1, v2, v3) -> null_if1 [0] if2(v0, v1, v2, v3) -> null_if2 [0] And the following fresh constants: null_eq, null_lt, null_bin2s, null_bin2ss, null_half, null_log, null_more, null_s2bin2, null_if1, null_if2 ---------------------------------------- (74) 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: eq(0, 0) -> true [1] eq(0, s(y)) -> false [1] eq(s(x), 0) -> false [1] eq(s(x), s(y)) -> eq(x, y) [1] lt(0, s(y)) -> true [1] lt(x, 0) -> false [1] lt(s(x), s(y)) -> lt(x, y) [1] bin2s(nil) -> 0 [1] bin2s(cons(x, xs)) -> bin2ss(x, xs) [1] bin2ss(x, nil) -> x [1] bin2ss(x, cons(0, xs)) -> bin2ss(double(x), xs) [1] bin2ss(x, cons(1, xs)) -> bin2ss(s(double(x)), xs) [1] half(0) -> 0 [1] half(s(0)) -> 0 [1] half(s(s(x))) -> s(half(x)) [1] log(0) -> 0 [1] log(s(0)) -> 0 [1] log(s(s(x))) -> s(log(half(s(s(x))))) [1] more(nil) -> nil [1] more(cons(xs, ys)) -> cons(cons(0, xs), cons(cons(1, xs), cons(xs, ys))) [1] s2bin(x) -> s2bin1(x, 0, cons(nil, nil)) [1] s2bin1(x, y, lists) -> if1(lt(y, log(x)), x, y, lists) [1] if1(true, x, y, lists) -> s2bin1(x, s(y), more(lists)) [1] if1(false, x, y, lists) -> s2bin2(x, lists) [1] s2bin2(x, nil) -> bug_list_not [1] s2bin2(x, cons(xs, ys)) -> if2(eq(x, bin2s(xs)), x, xs, ys) [1] if2(true, x, xs, ys) -> xs [1] if2(false, x, xs, ys) -> s2bin2(x, ys) [1] eq(v0, v1) -> null_eq [0] lt(v0, v1) -> null_lt [0] bin2s(v0) -> null_bin2s [0] bin2ss(v0, v1) -> null_bin2ss [0] half(v0) -> null_half [0] log(v0) -> null_log [0] more(v0) -> null_more [0] s2bin2(v0, v1) -> null_s2bin2 [0] if1(v0, v1, v2, v3) -> null_if1 [0] if2(v0, v1, v2, v3) -> null_if2 [0] The TRS has the following type information: eq :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> true:false:null_eq:null_lt 0 :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 true :: true:false:null_eq:null_lt s :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 false :: true:false:null_eq:null_lt lt :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> true:false:null_eq:null_lt bin2s :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 nil :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 cons :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 bin2ss :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 double :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 1 :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 half :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 log :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 more :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 s2bin :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 s2bin1 :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 if1 :: true:false:null_eq:null_lt -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 s2bin2 :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 bug_list_not :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 if2 :: true:false:null_eq:null_lt -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 -> 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 null_eq :: true:false:null_eq:null_lt null_lt :: true:false:null_eq:null_lt null_bin2s :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 null_bin2ss :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 null_half :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 null_log :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 null_more :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 null_s2bin2 :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 null_if1 :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 null_if2 :: 0:s:nil:cons:double:1:bug_list_not:null_bin2s:null_bin2ss:null_half:null_log:null_more:null_s2bin2:null_if1:null_if2 Rewrite Strategy: INNERMOST ---------------------------------------- (75) 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 => 3 1 => 1 bug_list_not => 2 null_eq => 0 null_lt => 0 null_bin2s => 0 null_bin2ss => 0 null_half => 0 null_log => 0 null_more => 0 null_s2bin2 => 0 null_if1 => 0 null_if2 => 0 ---------------------------------------- (76) Obligation: Complexity RNTS consisting of the following rules: bin2s(z) -{ 1 }-> bin2ss(x, xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 bin2s(z) -{ 1 }-> 0 :|: z = 3 bin2s(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 bin2ss(z, z') -{ 1 }-> x :|: z' = 3, x >= 0, z = x bin2ss(z, z') -{ 1 }-> bin2ss(1 + x, xs) :|: xs >= 0, z' = 1 + 0 + xs, x >= 0, z = x bin2ss(z, z') -{ 1 }-> bin2ss(1 + (1 + x), xs) :|: xs >= 0, z' = 1 + 1 + xs, x >= 0, z = x bin2ss(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 eq(z, z') -{ 1 }-> eq(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0 eq(z, z') -{ 1 }-> 1 :|: z' = 1 + y, y >= 0, z = 0 eq(z, z') -{ 1 }-> 1 :|: x >= 0, z = 1 + x, z' = 0 eq(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 half(z) -{ 1 }-> 0 :|: z = 0 half(z) -{ 1 }-> 0 :|: z = 1 + 0 half(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 half(z) -{ 1 }-> 1 + half(x) :|: x >= 0, z = 1 + (1 + x) if1(z, z', z'', z1) -{ 1 }-> s2bin2(x, lists) :|: z' = x, z'' = y, z = 1, x >= 0, y >= 0, lists >= 0, z1 = lists if1(z, z', z'', z1) -{ 1 }-> s2bin1(x, 1 + y, more(lists)) :|: z = 2, z' = x, z'' = y, x >= 0, y >= 0, lists >= 0, z1 = lists if1(z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0 if2(z, z', z'', z1) -{ 1 }-> xs :|: z = 2, xs >= 0, z' = x, ys >= 0, x >= 0, z'' = xs, z1 = ys if2(z, z', z'', z1) -{ 1 }-> s2bin2(x, ys) :|: xs >= 0, z' = x, z = 1, ys >= 0, x >= 0, z'' = xs, z1 = ys if2(z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0 log(z) -{ 1 }-> 0 :|: z = 0 log(z) -{ 1 }-> 0 :|: z = 1 + 0 log(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 log(z) -{ 1 }-> 1 + log(half(1 + (1 + x))) :|: x >= 0, z = 1 + (1 + x) lt(z, z') -{ 1 }-> lt(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x lt(z, z') -{ 1 }-> 2 :|: z' = 1 + y, y >= 0, z = 0 lt(z, z') -{ 1 }-> 1 :|: x >= 0, z = x, z' = 0 lt(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 more(z) -{ 1 }-> 3 :|: z = 3 more(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 more(z) -{ 1 }-> 1 + (1 + 0 + xs) + (1 + (1 + 1 + xs) + (1 + xs + ys)) :|: z = 1 + xs + ys, xs >= 0, ys >= 0 s2bin(z) -{ 1 }-> s2bin1(x, 0, 1 + 3 + 3) :|: x >= 0, z = x s2bin1(z, z', z'') -{ 1 }-> if1(lt(y, log(x)), x, y, lists) :|: x >= 0, y >= 0, lists >= 0, z'' = lists, z = x, z' = y s2bin2(z, z') -{ 1 }-> if2(eq(x, bin2s(xs)), x, xs, ys) :|: xs >= 0, ys >= 0, x >= 0, z' = 1 + xs + ys, z = x s2bin2(z, z') -{ 1 }-> 2 :|: z' = 3, x >= 0, z = x s2bin2(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 Only complete derivations are relevant for the runtime complexity. ---------------------------------------- (77) CpxTrsToCdtProof (UPPER BOUND(ID)) Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT ---------------------------------------- (78) Obligation: Complexity Dependency Tuples Problem Rules: eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) half(0) -> 0 half(s(0)) -> 0 half(s(s(z0))) -> s(half(z0)) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) s2bin(z0) -> s2bin1(z0, 0, cons(nil, nil)) s2bin1(z0, z1, z2) -> if1(lt(z1, log(z0)), z0, z1, z2) if1(true, z0, z1, z2) -> s2bin1(z0, s(z1), more(z2)) if1(false, z0, z1, z2) -> s2bin2(z0, z2) s2bin2(z0, nil) -> bug_list_not s2bin2(z0, cons(z1, z2)) -> if2(eq(z0, bin2s(z1)), z0, z1, z2) if2(true, z0, z1, z2) -> z1 if2(false, z0, z1, z2) -> s2bin2(z0, z2) Tuples: EQ(0, 0) -> c EQ(0, s(z0)) -> c1 EQ(s(z0), 0) -> c2 EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(0, s(z0)) -> c4 LT(z0, 0) -> c5 LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(nil) -> c7 BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, nil) -> c9 BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(0) -> c12 HALF(s(0)) -> c13 HALF(s(s(z0))) -> c14(HALF(z0)) LOG(0) -> c15 LOG(s(0)) -> c16 LOG(s(s(z0))) -> c17(LOG(half(s(s(z0)))), HALF(s(s(z0)))) MORE(nil) -> c18 MORE(cons(z0, z1)) -> c19 S2BIN(z0) -> c20(S2BIN1(z0, 0, cons(nil, nil))) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2)), MORE(z2)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, nil) -> c24 S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(true, z0, z1, z2) -> c26 IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) S tuples: EQ(0, 0) -> c EQ(0, s(z0)) -> c1 EQ(s(z0), 0) -> c2 EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(0, s(z0)) -> c4 LT(z0, 0) -> c5 LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(nil) -> c7 BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, nil) -> c9 BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(0) -> c12 HALF(s(0)) -> c13 HALF(s(s(z0))) -> c14(HALF(z0)) LOG(0) -> c15 LOG(s(0)) -> c16 LOG(s(s(z0))) -> c17(LOG(half(s(s(z0)))), HALF(s(s(z0)))) MORE(nil) -> c18 MORE(cons(z0, z1)) -> c19 S2BIN(z0) -> c20(S2BIN1(z0, 0, cons(nil, nil))) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2)), MORE(z2)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, nil) -> c24 S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(true, z0, z1, z2) -> c26 IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) K tuples:none Defined Rule Symbols: eq_2, lt_2, bin2s_1, bin2ss_2, half_1, log_1, more_1, s2bin_1, s2bin1_3, if1_4, s2bin2_2, if2_4 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, LOG_1, MORE_1, S2BIN_1, S2BIN1_3, IF1_4, S2BIN2_2, IF2_4 Compound Symbols: c, c1, c2, c3_1, c4, c5, c6_1, c7, c8_1, c9, c10_1, c11_1, c12, c13, c14_1, c15, c16, c17_2, c18, c19, c20_1, c21_3, c22_2, c23_1, c24, c25_3, c26, c27_1 ---------------------------------------- (79) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: S2BIN(z0) -> c20(S2BIN1(z0, 0, cons(nil, nil))) Removed 15 trailing nodes: LOG(0) -> c15 S2BIN2(z0, nil) -> c24 LOG(s(0)) -> c16 EQ(0, 0) -> c IF2(true, z0, z1, z2) -> c26 LT(0, s(z0)) -> c4 LT(z0, 0) -> c5 HALF(0) -> c12 MORE(cons(z0, z1)) -> c19 BIN2S(nil) -> c7 EQ(s(z0), 0) -> c2 EQ(0, s(z0)) -> c1 MORE(nil) -> c18 HALF(s(0)) -> c13 BIN2SS(z0, nil) -> c9 ---------------------------------------- (80) Obligation: Complexity Dependency Tuples Problem Rules: eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) half(0) -> 0 half(s(0)) -> 0 half(s(s(z0))) -> s(half(z0)) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) s2bin(z0) -> s2bin1(z0, 0, cons(nil, nil)) s2bin1(z0, z1, z2) -> if1(lt(z1, log(z0)), z0, z1, z2) if1(true, z0, z1, z2) -> s2bin1(z0, s(z1), more(z2)) if1(false, z0, z1, z2) -> s2bin2(z0, z2) s2bin2(z0, nil) -> bug_list_not s2bin2(z0, cons(z1, z2)) -> if2(eq(z0, bin2s(z1)), z0, z1, z2) if2(true, z0, z1, z2) -> z1 if2(false, z0, z1, z2) -> s2bin2(z0, z2) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) LOG(s(s(z0))) -> c17(LOG(half(s(s(z0)))), HALF(s(s(z0)))) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2)), MORE(z2)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) LOG(s(s(z0))) -> c17(LOG(half(s(s(z0)))), HALF(s(s(z0)))) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2)), MORE(z2)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) K tuples:none Defined Rule Symbols: eq_2, lt_2, bin2s_1, bin2ss_2, half_1, log_1, more_1, s2bin_1, s2bin1_3, if1_4, s2bin2_2, if2_4 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, LOG_1, S2BIN1_3, IF1_4, S2BIN2_2, IF2_4 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c17_2, c21_3, c22_2, c23_1, c25_3, c27_1 ---------------------------------------- (81) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (82) Obligation: Complexity Dependency Tuples Problem Rules: eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) half(0) -> 0 half(s(0)) -> 0 half(s(s(z0))) -> s(half(z0)) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) s2bin(z0) -> s2bin1(z0, 0, cons(nil, nil)) s2bin1(z0, z1, z2) -> if1(lt(z1, log(z0)), z0, z1, z2) if1(true, z0, z1, z2) -> s2bin1(z0, s(z1), more(z2)) if1(false, z0, z1, z2) -> s2bin2(z0, z2) s2bin2(z0, nil) -> bug_list_not s2bin2(z0, cons(z1, z2)) -> if2(eq(z0, bin2s(z1)), z0, z1, z2) if2(true, z0, z1, z2) -> z1 if2(false, z0, z1, z2) -> s2bin2(z0, z2) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) LOG(s(s(z0))) -> c17(LOG(half(s(s(z0)))), HALF(s(s(z0)))) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) LOG(s(s(z0))) -> c17(LOG(half(s(s(z0)))), HALF(s(s(z0)))) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) K tuples:none Defined Rule Symbols: eq_2, lt_2, bin2s_1, bin2ss_2, half_1, log_1, more_1, s2bin_1, s2bin1_3, if1_4, s2bin2_2, if2_4 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, LOG_1, S2BIN1_3, IF1_4, S2BIN2_2, IF2_4 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c17_2, c21_3, c23_1, c25_3, c27_1, c22_1 ---------------------------------------- (83) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: s2bin(z0) -> s2bin1(z0, 0, cons(nil, nil)) s2bin1(z0, z1, z2) -> if1(lt(z1, log(z0)), z0, z1, z2) if1(true, z0, z1, z2) -> s2bin1(z0, s(z1), more(z2)) if1(false, z0, z1, z2) -> s2bin2(z0, z2) s2bin2(z0, nil) -> bug_list_not s2bin2(z0, cons(z1, z2)) -> if2(eq(z0, bin2s(z1)), z0, z1, z2) if2(true, z0, z1, z2) -> z1 if2(false, z0, z1, z2) -> s2bin2(z0, z2) ---------------------------------------- (84) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) LOG(s(s(z0))) -> c17(LOG(half(s(s(z0)))), HALF(s(s(z0)))) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) LOG(s(s(z0))) -> c17(LOG(half(s(s(z0)))), HALF(s(s(z0)))) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) K tuples:none Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, LOG_1, S2BIN1_3, IF1_4, S2BIN2_2, IF2_4 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c17_2, c21_3, c23_1, c25_3, c27_1, c22_1 ---------------------------------------- (85) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) We considered the (Usable) Rules: lt(0, s(z0)) -> true lt(s(z0), s(z1)) -> lt(z0, z1) lt(z0, 0) -> false And the Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) LOG(s(s(z0))) -> c17(LOG(half(s(s(z0)))), HALF(s(s(z0)))) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = [1] POL(BIN2S(x_1)) = 0 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_3 POL(IF2(x_1, x_2, x_3, x_4)) = x_2 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] + x_1 + x_2 POL(S2BIN2(x_1, x_2)) = x_1 POL(bin2s(x_1)) = [1] + x_1 POL(bin2ss(x_1, x_2)) = [1] + x_1 + x_2 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c6(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(double(x_1)) = [1] + x_1 POL(eq(x_1, x_2)) = [1] POL(false) = [1] POL(half(x_1)) = [1] + x_1 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = [1] POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (86) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) LOG(s(s(z0))) -> c17(LOG(half(s(s(z0)))), HALF(s(s(z0)))) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) LOG(s(s(z0))) -> c17(LOG(half(s(s(z0)))), HALF(s(s(z0)))) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, LOG_1, S2BIN1_3, IF1_4, S2BIN2_2, IF2_4 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c17_2, c21_3, c23_1, c25_3, c27_1, c22_1 ---------------------------------------- (87) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LOG(s(s(z0))) -> c17(LOG(half(s(s(z0)))), HALF(s(s(z0)))) by LOG(s(s(z0))) -> c17(LOG(s(half(z0))), HALF(s(s(z0)))) ---------------------------------------- (88) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(z0))) -> c17(LOG(s(half(z0))), HALF(s(s(z0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(z0))) -> c17(LOG(s(half(z0))), HALF(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, S2BIN1_3, IF1_4, S2BIN2_2, IF2_4, LOG_1 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c21_3, c23_1, c25_3, c27_1, c22_1, c17_2 ---------------------------------------- (89) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN1(z0, z1, z2) -> c21(IF1(lt(z1, log(z0)), z0, z1, z2), LT(z1, log(z0)), LOG(z0)) by S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0)), LOG(0)) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0))), LOG(s(0))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) ---------------------------------------- (90) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(z0))) -> c17(LOG(s(half(z0))), HALF(s(s(z0)))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0)), LOG(0)) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0))), LOG(s(0))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(z0))) -> c17(LOG(s(half(z0))), HALF(s(s(z0)))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0)), LOG(0)) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0))), LOG(s(0))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, S2BIN2_2, IF2_4, LOG_1, S2BIN1_3 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c25_3, c27_1, c22_1, c17_2, c21_3 ---------------------------------------- (91) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (92) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(z0))) -> c17(LOG(s(half(z0))), HALF(s(s(z0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(z0))) -> c17(LOG(s(half(z0))), HALF(s(s(z0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, S2BIN2_2, IF2_4, LOG_1, S2BIN1_3 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c25_3, c27_1, c22_1, c17_2, c21_3, c21_2 ---------------------------------------- (93) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(z0, cons(z1, z2)) -> c25(IF2(eq(z0, bin2s(z1)), z0, z1, z2), EQ(z0, bin2s(z1)), BIN2S(z1)) by S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil)), BIN2S(nil)) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) ---------------------------------------- (94) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(z0))) -> c17(LOG(s(half(z0))), HALF(s(s(z0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil)), BIN2S(nil)) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(z0))) -> c17(LOG(s(half(z0))), HALF(s(s(z0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil)), BIN2S(nil)) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c21_3, c21_2, c25_3 ---------------------------------------- (95) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (96) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(z0))) -> c17(LOG(s(half(z0))), HALF(s(s(z0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(z0))) -> c17(LOG(s(half(z0))), HALF(s(s(z0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c21_3, c21_2, c25_3, c25_2 ---------------------------------------- (97) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace LOG(s(s(z0))) -> c17(LOG(s(half(z0))), HALF(s(s(z0)))) by LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(0))) -> c17(LOG(s(0)), HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(LOG(s(0)), HALF(s(s(s(0))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) ---------------------------------------- (98) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(0))) -> c17(LOG(s(0)), HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(LOG(s(0)), HALF(s(s(s(0))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(0))) -> c17(LOG(s(0)), HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(LOG(s(0)), HALF(s(s(s(0))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN1_3, S2BIN2_2, LOG_1 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c21_3, c21_2, c25_3, c25_2, c17_2, c17_1 ---------------------------------------- (99) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (100) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN1_3, S2BIN2_2, LOG_1 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c21_3, c21_2, c25_3, c25_2, c17_2, c17_1 ---------------------------------------- (101) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(half(s(s(z0)))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) by S2BIN1(s(s(x0)), 0, x2) -> c21(IF1(true, s(s(x0)), 0, x2), LT(0, log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) ---------------------------------------- (102) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), 0, x2) -> c21(IF1(true, s(s(x0)), 0, x2), LT(0, log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), 0, x2) -> c21(IF1(true, s(s(x0)), 0, x2), LT(0, log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN1_3, S2BIN2_2, LOG_1 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c21_2, c25_3, c25_2, c17_2, c17_1, c21_3 ---------------------------------------- (103) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (104) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(s(s(x0)), 0, x2) -> c21(IF1(true, s(s(x0)), 0, x2), LOG(s(s(x0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(s(s(x0)), 0, x2) -> c21(IF1(true, s(s(x0)), 0, x2), LOG(s(s(x0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN1_3, S2BIN2_2, LOG_1 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c21_2, c25_3, c25_2, c17_2, c17_1, c21_3 ---------------------------------------- (105) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (106) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(s(s(x0)), 0, x2) -> c(IF1(true, s(s(x0)), 0, x2)) S2BIN1(s(s(x0)), 0, x2) -> c(LOG(s(s(x0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(s(s(x0)), 0, x2) -> c(IF1(true, s(s(x0)), 0, x2)) S2BIN1(s(s(x0)), 0, x2) -> c(LOG(s(s(x0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN1_3, S2BIN2_2, LOG_1 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c21_2, c25_3, c25_2, c17_2, c17_1, c21_3, c_1 ---------------------------------------- (107) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 2 leading nodes: S2BIN1(s(s(x0)), 0, x2) -> c(IF1(true, s(s(x0)), 0, x2)) S2BIN1(s(s(x0)), 0, x2) -> c(LOG(s(s(x0)))) ---------------------------------------- (108) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN1_3, S2BIN2_2, LOG_1 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c21_2, c25_3, c25_2, c17_2, c17_1, c21_3 ---------------------------------------- (109) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN1(0, x1, x2) -> c21(IF1(lt(x1, 0), 0, x1, x2), LT(x1, log(0))) by S2BIN1(0, z0, x1) -> c21(IF1(false, 0, z0, x1), LT(z0, log(0))) ---------------------------------------- (110) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c21(IF1(false, 0, z0, x1), LT(z0, log(0))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c21(IF1(false, 0, z0, x1), LT(z0, log(0))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN1_3, S2BIN2_2, LOG_1 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c21_2, c25_3, c25_2, c17_2, c17_1, c21_3 ---------------------------------------- (111) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (112) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN1_3, S2BIN2_2, LOG_1 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c21_2, c25_3, c25_2, c17_2, c17_1, c21_3, c_1 ---------------------------------------- (113) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) We considered the (Usable) Rules:none And the Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = [1] POL(1) = [1] POL(BIN2S(x_1)) = x_1 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_2 + x_3 POL(IF2(x_1, x_2, x_3, x_4)) = x_2 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = x_1 + x_2 POL(S2BIN2(x_1, x_2)) = x_1 POL(bin2s(x_1)) = [1] + x_1 POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c21(x_1, x_2)) = x_1 + x_2 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c6(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(double(x_1)) = [1] + x_1 POL(eq(x_1, x_2)) = 0 POL(false) = 0 POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = 0 ---------------------------------------- (114) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN1_3, S2BIN2_2, LOG_1 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c21_2, c25_3, c25_2, c17_2, c17_1, c21_3, c_1 ---------------------------------------- (115) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) We considered the (Usable) Rules: lt(0, s(z0)) -> true lt(s(z0), s(z1)) -> lt(z0, z1) lt(z0, 0) -> false And the Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = [1] POL(BIN2S(x_1)) = x_1 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_1 + x_3 POL(IF2(x_1, x_2, x_3, x_4)) = 0 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] + x_2 POL(S2BIN2(x_1, x_2)) = 0 POL(bin2s(x_1)) = [1] + x_1 POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c21(x_1, x_2)) = x_1 + x_2 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c6(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(double(x_1)) = [1] + x_1 POL(eq(x_1, x_2)) = 0 POL(false) = 0 POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (116) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN1_3, S2BIN2_2, LOG_1 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c21_2, c25_3, c25_2, c17_2, c17_1, c21_3, c_1 ---------------------------------------- (117) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN1(s(0), x1, x2) -> c21(IF1(lt(x1, 0), s(0), x1, x2), LT(x1, log(s(0)))) by S2BIN1(s(0), z0, x1) -> c21(IF1(false, s(0), z0, x1), LT(z0, log(s(0)))) ---------------------------------------- (118) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c21(IF1(false, s(0), z0, x1), LT(z0, log(s(0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(s(0), z0, x1) -> c21(IF1(false, s(0), z0, x1), LT(z0, log(s(0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN2_2, LOG_1, S2BIN1_3 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c25_3, c25_2, c17_2, c17_1, c21_3, c_1, c21_2 ---------------------------------------- (119) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (120) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN2_2, LOG_1, S2BIN1_3 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c25_3, c25_2, c17_2, c17_1, c21_3, c_1, c1_1 ---------------------------------------- (121) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) We considered the (Usable) Rules: lt(0, s(z0)) -> true lt(s(z0), s(z1)) -> lt(z0, z1) lt(z0, 0) -> false And the Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = [1] POL(BIN2S(x_1)) = x_1 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_1 + x_3 POL(IF2(x_1, x_2, x_3, x_4)) = 0 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] + x_2 POL(S2BIN2(x_1, x_2)) = 0 POL(bin2s(x_1)) = [1] + x_1 POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c6(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(double(x_1)) = [1] + x_1 POL(eq(x_1, x_2)) = [1] + x_1 POL(false) = 0 POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (122) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN2_2, LOG_1, S2BIN1_3 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c25_3, c25_2, c17_2, c17_1, c21_3, c_1, c1_1 ---------------------------------------- (123) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(cons(z0, z1), x2)) -> c25(IF2(eq(x0, bin2ss(z0, z1)), x0, cons(z0, z1), x2), EQ(x0, bin2s(cons(z0, z1))), BIN2S(cons(z0, z1))) by S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c25(EQ(x0, bin2s(cons(x1, x2))), BIN2S(cons(x1, x2))) ---------------------------------------- (124) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c25(EQ(x0, bin2s(cons(x1, x2))), BIN2S(cons(x1, x2))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c25(EQ(x0, bin2s(cons(x1, x2))), BIN2S(cons(x1, x2))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN2_2, LOG_1, S2BIN1_3 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c25_2, c17_2, c17_1, c21_3, c_1, c1_1, c25_3 ---------------------------------------- (125) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (126) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN2_2, LOG_1, S2BIN1_3 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c25_2, c17_2, c17_1, c21_3, c_1, c1_1, c25_3, c2_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. S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) We considered the (Usable) Rules: lt(0, s(z0)) -> true lt(s(z0), s(z1)) -> lt(z0, z1) lt(z0, 0) -> false And the Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = x_1 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_1 + x_3 POL(IF2(x_1, x_2, x_3, x_4)) = [1] POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] + x_2 POL(S2BIN2(x_1, x_2)) = [1] POL(bin2s(x_1)) = [1] + x_1 POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c6(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(double(x_1)) = x_1 POL(eq(x_1, x_2)) = [1] POL(false) = [1] POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (128) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, S2BIN2_2, LOG_1, S2BIN1_3 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c25_2, c17_2, c17_1, c21_3, c_1, c1_1, c25_3, c2_1 ---------------------------------------- (129) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(nil, x2)) -> c25(IF2(eq(x0, 0), x0, nil, x2), EQ(x0, bin2s(nil))) by S2BIN2(0, cons(nil, x1)) -> c25(IF2(true, 0, nil, x1), EQ(0, bin2s(nil))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) ---------------------------------------- (130) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(0, cons(nil, x1)) -> c25(IF2(true, 0, nil, x1), EQ(0, bin2s(nil))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(0, cons(nil, x1)) -> c25(IF2(true, 0, nil, x1), EQ(0, bin2s(nil))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c21_3, c_1, c1_1, c25_3, c2_1, c25_2, c25_1 ---------------------------------------- (131) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: S2BIN2(0, cons(nil, x1)) -> c25(IF2(true, 0, nil, x1), EQ(0, bin2s(nil))) ---------------------------------------- (132) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c21_3, c_1, c1_1, c25_3, c2_1, c25_2, c25_1 ---------------------------------------- (133) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) We considered the (Usable) Rules: lt(0, s(z0)) -> true lt(s(z0), s(z1)) -> lt(z0, z1) lt(z0, 0) -> false And the Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = 0 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_1 + x_3 POL(IF2(x_1, x_2, x_3, x_4)) = [1] POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] + x_2 POL(S2BIN2(x_1, x_2)) = [1] POL(bin2s(x_1)) = [1] + x_1 POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c6(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(double(x_1)) = x_1 POL(eq(x_1, x_2)) = [1] + x_1 POL(false) = [1] POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (134) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c21_3, c_1, c1_1, c25_3, c2_1, c25_2, c25_1 ---------------------------------------- (135) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(half(s(s(x0))))), s(s(x0)), s(z0), x2), LT(s(z0), log(s(s(x0)))), LOG(s(s(x0)))) by S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) ---------------------------------------- (136) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c21_3, c_1, c1_1, c25_3, c2_1, c25_2, c25_1 ---------------------------------------- (137) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace S2BIN1(s(s(z0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(half(z0))))), s(s(z0)), x1, x2), LT(x1, log(s(s(z0)))), LOG(s(s(z0)))) by S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) ---------------------------------------- (138) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c25_3, c2_1, c25_2, c25_1, c21_3 ---------------------------------------- (139) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) by S2BIN1(0, z0, z1) -> c(LT(z0, 0)) ---------------------------------------- (140) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(0, z0, z1) -> c(LT(z0, 0)) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(LT(z0, log(0))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c25_3, c2_1, c25_2, c25_1, c21_3 ---------------------------------------- (141) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: S2BIN1(0, z0, z1) -> c(LT(z0, 0)) ---------------------------------------- (142) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c25_3, c2_1, c25_2, c25_1, c21_3 ---------------------------------------- (143) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) by S2BIN1(s(0), z0, z1) -> c1(LT(z0, 0)) ---------------------------------------- (144) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(0), z0, z1) -> c1(LT(z0, 0)) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN1(s(0), z0, x1) -> c1(LT(z0, log(s(0)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c25_3, c2_1, c25_2, c25_1, c21_3 ---------------------------------------- (145) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: S2BIN1(s(0), z0, z1) -> c1(LT(z0, 0)) ---------------------------------------- (146) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c25_3, c2_1, c25_2, c25_1, c21_3 ---------------------------------------- (147) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace S2BIN2(x0, cons(cons(z0, nil), x3)) -> c25(IF2(eq(x0, z0), x0, cons(z0, nil), x3), EQ(x0, bin2s(cons(z0, nil))), BIN2S(cons(z0, nil))) by S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) ---------------------------------------- (148) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) S tuples: EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: EQ_2, LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2 Compound Symbols: c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c25_3, c2_1, c25_2, c25_1, c21_3 ---------------------------------------- (149) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) by EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) ---------------------------------------- (150) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c25_3, c2_1, c25_2, c25_1, c21_3, c3_1 ---------------------------------------- (151) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(double(z0), z1)), x0, cons(z0, cons(0, z1)), x3), EQ(x0, bin2s(cons(z0, cons(0, z1)))), BIN2S(cons(z0, cons(0, z1)))) by S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) ---------------------------------------- (152) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c25_3, c2_1, c25_2, c25_1, c21_3, c3_1 ---------------------------------------- (153) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(z0)), z1)), x0, cons(z0, cons(1, z1)), x3), EQ(x0, bin2s(cons(z0, cons(1, z1)))), BIN2S(cons(z0, cons(1, z1)))) by S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) ---------------------------------------- (154) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c25_2, c25_1, c21_3, c25_3, c3_1 ---------------------------------------- (155) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) by S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) ---------------------------------------- (156) Obligation: Complexity Dependency Tuples Problem Rules: half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2s(nil) -> 0 bin2s(cons(z0, z1)) -> bin2ss(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: half_1, lt_2, log_1, eq_2, bin2s_1, bin2ss_2, more_1 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c25_2, c25_1, c21_3, c25_3, c3_1 ---------------------------------------- (157) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: bin2s(cons(z0, z1)) -> bin2ss(z0, z1) ---------------------------------------- (158) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 bin2s(nil) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: more_1, half_1, bin2s_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c25_2, c25_1, c21_3, c25_3, c3_1 ---------------------------------------- (159) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(s(z0), cons(nil, x1)) -> c25(IF2(false, s(z0), nil, x1), EQ(s(z0), bin2s(nil))) by S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1), EQ(s(x0), 0)) ---------------------------------------- (160) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 bin2s(nil) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1), EQ(s(x0), 0)) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1), EQ(s(x0), 0)) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: more_1, half_1, bin2s_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c25_1, c21_3, c25_3, c3_1, c25_2 ---------------------------------------- (161) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (162) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 bin2s(nil) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: more_1, half_1, bin2s_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c25_1, c21_3, c25_3, c3_1 ---------------------------------------- (163) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) by S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, 0)) ---------------------------------------- (164) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 bin2s(nil) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, 0)) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(EQ(x0, bin2s(cons(x1, x2)))) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, bin2s(nil))) Defined Rule Symbols: more_1, half_1, bin2s_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c21_3, c25_3, c3_1, c25_1 ---------------------------------------- (165) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: S2BIN2(x0, cons(nil, x1)) -> c25(EQ(x0, 0)) ---------------------------------------- (166) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 bin2s(nil) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) Defined Rule Symbols: more_1, half_1, bin2s_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c21_3, c25_3, c3_1, c25_1 ---------------------------------------- (167) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: bin2s(nil) -> 0 ---------------------------------------- (168) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c21_3, c25_3, c3_1, c25_1 ---------------------------------------- (169) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN1(s(s(z0)), s(z1), z2) -> c21(IF1(lt(z1, log(half(s(s(z0))))), s(s(z0)), s(z1), z2), LT(s(z1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) by S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) ---------------------------------------- (170) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c21_3, c25_3, c3_1, c25_1 ---------------------------------------- (171) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN1(s(s(z0)), z1, z2) -> c21(IF1(lt(z1, s(log(s(half(z0))))), s(s(z0)), z1, z2), LT(z1, s(log(half(s(s(z0)))))), LOG(s(s(z0)))) by S2BIN1(s(s(x0)), 0, x2) -> c21(IF1(true, s(s(x0)), 0, x2), LT(0, s(log(half(s(s(x0)))))), LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(s(half(x0)))), s(s(x0)), s(z0), x2), LT(s(z0), s(log(half(s(s(x0)))))), LOG(s(s(x0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c21(LT(x1, s(log(half(s(s(x0)))))), LOG(s(s(x0)))) ---------------------------------------- (172) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(x0)), 0, x2) -> c21(IF1(true, s(s(x0)), 0, x2), LT(0, s(log(half(s(s(x0)))))), LOG(s(s(x0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c21(LT(x1, s(log(half(s(s(x0)))))), LOG(s(s(x0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(x0)), 0, x2) -> c21(IF1(true, s(s(x0)), 0, x2), LT(0, s(log(half(s(s(x0)))))), LOG(s(s(x0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c21(LT(x1, s(log(half(s(s(x0)))))), LOG(s(s(x0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c25_3, c3_1, c25_1, c21_3, c21_2 ---------------------------------------- (173) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (174) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c21(LT(x1, s(log(half(s(s(x0)))))), LOG(s(s(x0)))) S2BIN1(s(s(x0)), 0, x2) -> c21(IF1(true, s(s(x0)), 0, x2), LOG(s(s(x0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c21(LT(x1, s(log(half(s(s(x0)))))), LOG(s(s(x0)))) S2BIN1(s(s(x0)), 0, x2) -> c21(IF1(true, s(s(x0)), 0, x2), LOG(s(s(x0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c25_3, c3_1, c25_1, c21_3, c21_2 ---------------------------------------- (175) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (176) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN1(s(s(x0)), 0, x2) -> c4(IF1(true, s(s(x0)), 0, x2)) S2BIN1(s(s(x0)), 0, x2) -> c4(LOG(s(s(x0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN1(s(s(x0)), 0, x2) -> c4(IF1(true, s(s(x0)), 0, x2)) S2BIN1(s(s(x0)), 0, x2) -> c4(LOG(s(s(x0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c25_3, c3_1, c25_1, c21_3, c4_1 ---------------------------------------- (177) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 2 leading nodes: S2BIN1(s(s(x0)), 0, x2) -> c4(IF1(true, s(s(x0)), 0, x2)) S2BIN1(s(s(x0)), 0, x2) -> c4(LOG(s(s(x0)))) ---------------------------------------- (178) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c25_3, c3_1, c25_1, c21_3, c4_1 ---------------------------------------- (179) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) We considered the (Usable) Rules:none And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = 0 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_2 POL(IF2(x_1, x_2, x_3, x_4)) = 0 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = x_1 POL(S2BIN2(x_1, x_2)) = 0 POL(bin2ss(x_1, x_2)) = [1] + x_1 + x_2 POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c6(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(double(x_1)) = x_1 POL(eq(x_1, x_2)) = [1] POL(false) = 0 POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = [1] POL(true) = [1] ---------------------------------------- (180) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c25_3, c3_1, c25_1, c21_3, c4_1 ---------------------------------------- (181) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(z0, cons(cons(z1, nil), z2)) -> c25(IF2(eq(z0, z1), z0, cons(z1, nil), z2), EQ(z0, bin2ss(z1, nil)), BIN2S(cons(z1, nil))) by S2BIN2(0, cons(cons(0, nil), x2)) -> c25(IF2(true, 0, cons(0, nil), x2), EQ(0, bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), EQ(0, bin2ss(s(z0), nil)), BIN2S(cons(s(z0), nil))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c25(EQ(x0, bin2ss(x1, nil)), BIN2S(cons(x1, nil))) ---------------------------------------- (182) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(IF2(true, 0, cons(0, nil), x2), EQ(0, bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), EQ(0, bin2ss(s(z0), nil)), BIN2S(cons(s(z0), nil))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c25(EQ(x0, bin2ss(x1, nil)), BIN2S(cons(x1, nil))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(IF2(true, 0, cons(0, nil), x2), EQ(0, bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), EQ(0, bin2ss(s(z0), nil)), BIN2S(cons(s(z0), nil))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c25(EQ(x0, bin2ss(x1, nil)), BIN2S(cons(x1, nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_3, c25_1, c21_3, c4_1, c25_2 ---------------------------------------- (183) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 3 trailing tuple parts ---------------------------------------- (184) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c25(EQ(x0, bin2ss(x1, nil)), BIN2S(cons(x1, nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c25(EQ(x0, bin2ss(x1, nil)), BIN2S(cons(x1, nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_3, c25_1, c21_3, c4_1, c25_2 ---------------------------------------- (185) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (186) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_3, c25_1, c21_3, c4_1, c25_2, c5_1 ---------------------------------------- (187) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) We considered the (Usable) Rules:none And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = [1] POL(1) = 0 POL(BIN2S(x_1)) = 0 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_2 + x_3 POL(IF2(x_1, x_2, x_3, x_4)) = x_2 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = x_1 + x_2 POL(S2BIN2(x_1, x_2)) = x_1 POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c6(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(double(x_1)) = x_1 POL(eq(x_1, x_2)) = [1] POL(false) = 0 POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (188) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_3, c25_1, c21_3, c4_1, c25_2, c5_1 ---------------------------------------- (189) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) We considered the (Usable) Rules: eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) eq(0, 0) -> true And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = 0 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = [1] + x_3 POL(IF2(x_1, x_2, x_3, x_4)) = x_1 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] + x_2 POL(S2BIN2(x_1, x_2)) = [1] POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c6(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(double(x_1)) = x_1 POL(eq(x_1, x_2)) = [1] POL(false) = [1] POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (190) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_3, c25_1, c21_3, c4_1, c25_2, c5_1 ---------------------------------------- (191) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(z0, cons(cons(z1, cons(0, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(double(z1), z2)), z0, cons(z1, cons(0, z2)), z3), EQ(z0, bin2ss(z1, cons(0, z2))), BIN2S(cons(z1, cons(0, z2)))) by S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c25(IF2(eq(x0, double(x1)), x0, cons(x1, cons(0, nil)), x3), EQ(x0, bin2ss(x1, cons(0, nil))), BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, x2))), BIN2S(cons(x1, cons(0, x2)))) ---------------------------------------- (192) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c25(IF2(eq(x0, double(x1)), x0, cons(x1, cons(0, nil)), x3), EQ(x0, bin2ss(x1, cons(0, nil))), BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, x2))), BIN2S(cons(x1, cons(0, x2)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c25(IF2(eq(x0, double(x1)), x0, cons(x1, cons(0, nil)), x3), EQ(x0, bin2ss(x1, cons(0, nil))), BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, x2))), BIN2S(cons(x1, cons(0, x2)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_3, c25_1, c21_3, c4_1, c25_2, c5_1 ---------------------------------------- (193) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (194) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, x2))), BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, nil))), BIN2S(cons(x1, cons(0, nil)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, x2))), BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, nil))), BIN2S(cons(x1, cons(0, nil)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_3, c25_1, c21_3, c4_1, c25_2, c5_1 ---------------------------------------- (195) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (196) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_3, c25_1, c21_3, c4_1, c25_2, c5_1, c7_1 ---------------------------------------- (197) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) We considered the (Usable) Rules: eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) eq(0, 0) -> true And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = x_1 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = [1] + x_3 POL(IF2(x_1, x_2, x_3, x_4)) = x_1 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] + x_2 POL(S2BIN2(x_1, x_2)) = [1] POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 POL(c6(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(cons(x_1, x_2)) = 0 POL(double(x_1)) = 0 POL(eq(x_1, x_2)) = [1] POL(false) = [1] POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (198) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_3, c25_1, c21_3, c4_1, c25_2, c5_1, c7_1 ---------------------------------------- (199) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(z0, cons(cons(z1, cons(1, z2)), z3)) -> c25(IF2(eq(z0, bin2ss(s(double(z1)), z2)), z0, cons(z1, cons(1, z2)), z3), EQ(z0, bin2ss(z1, cons(1, z2))), BIN2S(cons(z1, cons(1, z2)))) by S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, x2))), BIN2S(cons(x1, cons(1, x2)))) ---------------------------------------- (200) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, x2))), BIN2S(cons(x1, cons(1, x2)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, x2))), BIN2S(cons(x1, cons(1, x2)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1 ---------------------------------------- (201) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (202) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1 ---------------------------------------- (203) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) We considered the (Usable) Rules: lt(0, s(z0)) -> true lt(s(z0), s(z1)) -> lt(z0, z1) lt(z0, 0) -> false And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = x_1 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_1 + x_3 POL(IF2(x_1, x_2, x_3, x_4)) = [1] POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] + x_2 POL(S2BIN2(x_1, x_2)) = [1] POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 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(cons(x_1, x_2)) = 0 POL(double(x_1)) = 0 POL(eq(x_1, x_2)) = [1] POL(false) = [1] POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (204) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1 ---------------------------------------- (205) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(z0, cons(cons(z1, z2), z3)) -> c2(EQ(z0, bin2ss(z1, z2))) by S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) ---------------------------------------- (206) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1 ---------------------------------------- (207) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) by S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c21(LT(s(x1), s(log(half(s(s(x0)))))), LOG(s(s(x0)))) ---------------------------------------- (208) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c21(LT(s(x1), s(log(half(s(s(x0)))))), LOG(s(s(x0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c21(LT(s(x1), s(log(half(s(s(x0)))))), LOG(s(s(x0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c21_2 ---------------------------------------- (209) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (210) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1 ---------------------------------------- (211) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) We considered the (Usable) Rules:none And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = 0 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = [1] POL(IF2(x_1, x_2, x_3, x_4)) = 0 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] POL(S2BIN2(x_1, x_2)) = 0 POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c12(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 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(cons(x_1, x_2)) = 0 POL(double(x_1)) = 0 POL(eq(x_1, x_2)) = [1] POL(false) = 0 POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (212) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(z0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(half(z0)))), s(s(z0)), s(x1), x2), LT(s(x1), s(log(half(s(s(z0)))))), LOG(s(s(z0)))) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1 ---------------------------------------- (213) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN1(s(s(x0)), s(z0), x2) -> c21(IF1(lt(z0, log(s(half(x0)))), s(s(x0)), s(z0), x2), LT(s(z0), s(log(half(s(s(x0)))))), LOG(s(s(x0)))) by S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c21(LT(s(x1), s(log(half(s(s(x0)))))), LOG(s(s(x0)))) ---------------------------------------- (214) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c21(LT(s(x1), s(log(half(s(s(x0)))))), LOG(s(s(x0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1, c21_2 ---------------------------------------- (215) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (216) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1, c13_1 ---------------------------------------- (217) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN1(s(s(s(s(z0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(half(z0)))))), s(s(s(s(z0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) by S2BIN1(s(s(s(s(x0)))), 0, x2) -> c21(IF1(true, s(s(s(s(x0)))), 0, x2), LT(0, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(x0)))), s(z0), x2) -> c21(IF1(lt(z0, log(s(s(half(x0))))), s(s(s(s(x0)))), s(z0), x2), LT(s(z0), s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) ---------------------------------------- (218) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), 0, x2) -> c21(IF1(true, s(s(s(s(x0)))), 0, x2), LT(0, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), 0, x2) -> c21(IF1(true, s(s(s(s(x0)))), 0, x2), LT(0, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1, c13_1, c21_2 ---------------------------------------- (219) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (220) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(x0)))), 0, x2) -> c21(IF1(true, s(s(s(s(x0)))), 0, x2), LOG(s(s(s(s(x0)))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(x0)))), 0, x2) -> c21(IF1(true, s(s(s(s(x0)))), 0, x2), LOG(s(s(s(s(x0)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1, c13_1, c21_2 ---------------------------------------- (221) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (222) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(x0)))), 0, x2) -> c15(IF1(true, s(s(s(s(x0)))), 0, x2)) S2BIN1(s(s(s(s(x0)))), 0, x2) -> c15(LOG(s(s(s(s(x0)))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(x0)))), 0, x2) -> c15(IF1(true, s(s(s(s(x0)))), 0, x2)) S2BIN1(s(s(s(s(x0)))), 0, x2) -> c15(LOG(s(s(s(s(x0)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1, c13_1, c15_1 ---------------------------------------- (223) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 2 leading nodes: S2BIN1(s(s(s(s(x0)))), 0, x2) -> c15(IF1(true, s(s(s(s(x0)))), 0, x2)) S2BIN1(s(s(s(s(x0)))), 0, x2) -> c15(LOG(s(s(s(s(x0)))))) ---------------------------------------- (224) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1, c13_1, c15_1 ---------------------------------------- (225) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) We considered the (Usable) Rules: lt(0, s(z0)) -> true lt(s(z0), s(z1)) -> lt(z0, z1) lt(z0, 0) -> false And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = 0 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_1 + x_2 POL(IF2(x_1, x_2, x_3, x_4)) = 0 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] + x_1 POL(S2BIN2(x_1, x_2)) = 0 POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c12(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 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(cons(x_1, x_2)) = 0 POL(double(x_1)) = 0 POL(eq(x_1, x_2)) = [1] POL(false) = 0 POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = [1] POL(true) = [1] ---------------------------------------- (226) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1, c13_1, c15_1 ---------------------------------------- (227) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN1(s(s(0)), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(0)), x1, x2), LT(x1, s(log(half(s(s(0)))))), LOG(s(s(0)))) by S2BIN1(s(s(0)), 0, x1) -> c21(IF1(true, s(s(0)), 0, x1), LT(0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(0)), s(z0), x1) -> c21(IF1(lt(z0, log(s(0))), s(s(0)), s(z0), x1), LT(s(z0), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) ---------------------------------------- (228) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), 0, x1) -> c21(IF1(true, s(s(0)), 0, x1), LT(0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), 0, x1) -> c21(IF1(true, s(s(0)), 0, x1), LT(0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1, c13_1, c15_1 ---------------------------------------- (229) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (230) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(0)), 0, x1) -> c21(IF1(true, s(s(0)), 0, x1), LOG(s(s(0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(0)), 0, x1) -> c21(IF1(true, s(s(0)), 0, x1), LOG(s(s(0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1, c13_1, c15_1, c21_2 ---------------------------------------- (231) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (232) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(0)), 0, x1) -> c16(IF1(true, s(s(0)), 0, x1)) S2BIN1(s(s(0)), 0, x1) -> c16(LOG(s(s(0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(0)), 0, x1) -> c16(IF1(true, s(s(0)), 0, x1)) S2BIN1(s(s(0)), 0, x1) -> c16(LOG(s(s(0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1, c13_1, c15_1, c16_1 ---------------------------------------- (233) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 2 leading nodes: S2BIN1(s(s(0)), 0, x1) -> c16(IF1(true, s(s(0)), 0, x1)) S2BIN1(s(s(0)), 0, x1) -> c16(LOG(s(s(0)))) ---------------------------------------- (234) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c21_3, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c12_1, c13_1, c15_1 ---------------------------------------- (235) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN1(s(s(s(0))), x1, x2) -> c21(IF1(lt(x1, s(log(s(0)))), s(s(s(0))), x1, x2), LT(x1, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) by S2BIN1(s(s(s(0))), 0, x1) -> c21(IF1(true, s(s(s(0))), 0, x1), LT(0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(0))), s(z0), x1) -> c21(IF1(lt(z0, log(s(0))), s(s(s(0))), s(z0), x1), LT(s(z0), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) ---------------------------------------- (236) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), 0, x1) -> c21(IF1(true, s(s(s(0))), 0, x1), LT(0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), 0, x1) -> c21(IF1(true, s(s(s(0))), 0, x1), LT(0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1 ---------------------------------------- (237) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (238) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(0))), 0, x1) -> c21(IF1(true, s(s(s(0))), 0, x1), LOG(s(s(s(0))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(0))), 0, x1) -> c21(IF1(true, s(s(s(0))), 0, x1), LOG(s(s(s(0))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c21_2 ---------------------------------------- (239) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (240) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(0))), 0, x1) -> c16(IF1(true, s(s(s(0))), 0, x1)) S2BIN1(s(s(s(0))), 0, x1) -> c16(LOG(s(s(s(0))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(0))), 0, x1) -> c16(IF1(true, s(s(s(0))), 0, x1)) S2BIN1(s(s(s(0))), 0, x1) -> c16(LOG(s(s(s(0))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1 ---------------------------------------- (241) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 2 leading nodes: S2BIN1(s(s(s(0))), 0, x1) -> c16(IF1(true, s(s(s(0))), 0, x1)) S2BIN1(s(s(s(0))), 0, x1) -> c16(LOG(s(s(s(0))))) ---------------------------------------- (242) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1 ---------------------------------------- (243) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) by S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) ---------------------------------------- (244) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1 ---------------------------------------- (245) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(s(z0), cons(cons(0, nil), x2)) -> c25(IF2(false, s(z0), cons(0, nil), x2), EQ(s(z0), bin2ss(0, nil)), BIN2S(cons(0, nil))) by S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), EQ(s(x0), 0), BIN2S(cons(0, nil))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) ---------------------------------------- (246) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), EQ(s(x0), 0), BIN2S(cons(0, nil))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), EQ(s(x0), 0), BIN2S(cons(0, nil))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1 ---------------------------------------- (247) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (248) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_3, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1 ---------------------------------------- (249) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(s(z0), cons(cons(s(z1), nil), x2)) -> c25(IF2(eq(z0, z1), s(z0), cons(s(z1), nil), x2), EQ(s(z0), bin2ss(s(z1), nil)), BIN2S(cons(s(z1), nil))) by S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(IF2(true, s(0), cons(s(0), nil), x2), EQ(s(0), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), EQ(s(0), bin2ss(s(s(z0)), nil)), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c25(EQ(s(x0), bin2ss(s(x1), nil)), BIN2S(cons(s(x1), nil))) ---------------------------------------- (250) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(IF2(true, s(0), cons(s(0), nil), x2), EQ(s(0), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), EQ(s(0), bin2ss(s(s(z0)), nil)), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c25(EQ(s(x0), bin2ss(s(x1), nil)), BIN2S(cons(s(x1), nil))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(IF2(true, s(0), cons(s(0), nil), x2), EQ(s(0), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), EQ(s(0), bin2ss(s(s(z0)), nil)), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c25(EQ(s(x0), bin2ss(s(x1), nil)), BIN2S(cons(s(x1), nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c25_3, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1 ---------------------------------------- (251) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 3 trailing tuple parts ---------------------------------------- (252) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c25(EQ(s(x0), bin2ss(s(x1), nil)), BIN2S(cons(s(x1), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c25(EQ(s(x0), bin2ss(s(x1), nil)), BIN2S(cons(s(x1), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c25_3, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1 ---------------------------------------- (253) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (254) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c25_3, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1 ---------------------------------------- (255) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) We considered the (Usable) Rules: lt(0, s(z0)) -> true lt(s(z0), s(z1)) -> lt(z0, z1) lt(z0, 0) -> false And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = 0 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_1 + x_2 POL(IF2(x_1, x_2, x_3, x_4)) = [1] POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] + x_1 POL(S2BIN2(x_1, x_2)) = [1] POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c12(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c16(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 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(cons(x_1, x_2)) = 0 POL(double(x_1)) = 0 POL(eq(x_1, x_2)) = [1] POL(false) = [1] POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = [1] POL(true) = [1] ---------------------------------------- (256) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c25_3, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1 ---------------------------------------- (257) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) by S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) ---------------------------------------- (258) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c25_3, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1 ---------------------------------------- (259) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(x1)), z1)), x0, cons(x1, cons(0, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, z1)))), BIN2S(cons(x1, cons(0, cons(0, z1))))) by S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c25(IF2(eq(x0, double(double(x1))), x0, cons(x1, cons(0, cons(0, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, nil)))), BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, cons(0, x2)))), BIN2S(cons(x1, cons(0, cons(0, x2))))) ---------------------------------------- (260) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c25(IF2(eq(x0, double(double(x1))), x0, cons(x1, cons(0, cons(0, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, nil)))), BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, cons(0, x2)))), BIN2S(cons(x1, cons(0, cons(0, x2))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c25(IF2(eq(x0, double(double(x1))), x0, cons(x1, cons(0, cons(0, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, nil)))), BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, cons(0, x2)))), BIN2S(cons(x1, cons(0, cons(0, x2))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c25_3, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1 ---------------------------------------- (261) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (262) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, cons(0, x2)))), BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, cons(0, nil)))), BIN2S(cons(x1, cons(0, cons(0, nil))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, cons(0, x2)))), BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, cons(0, nil)))), BIN2S(cons(x1, cons(0, cons(0, nil))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c25_3, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1 ---------------------------------------- (263) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (264) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c25_3, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1 ---------------------------------------- (265) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) We considered the (Usable) Rules: eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) eq(0, 0) -> true lt(0, s(z0)) -> true lt(s(z0), s(z1)) -> lt(z0, z1) lt(z0, 0) -> false And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = x_1 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_1 + x_3 POL(IF2(x_1, x_2, x_3, x_4)) = x_1 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] + x_2 POL(S2BIN2(x_1, x_2)) = [1] POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c12(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c16(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c18(x_1)) = x_1 POL(c2(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 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(cons(x_1, x_2)) = 0 POL(double(x_1)) = 0 POL(eq(x_1, x_2)) = [1] POL(false) = [1] POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (266) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c25_3, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1 ---------------------------------------- (267) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, z1)))), BIN2S(cons(x1, cons(0, cons(1, z1))))) by S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, cons(1, x2)))), BIN2S(cons(x1, cons(0, cons(1, x2))))) ---------------------------------------- (268) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, cons(1, x2)))), BIN2S(cons(x1, cons(0, cons(1, x2))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(0, cons(1, x2)))), BIN2S(cons(x1, cons(0, cons(1, x2))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1 ---------------------------------------- (269) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (270) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_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. S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) We considered the (Usable) Rules: lt(0, s(z0)) -> true lt(s(z0), s(z1)) -> lt(z0, z1) lt(z0, 0) -> false And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = x_1 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_1 POL(IF2(x_1, x_2, x_3, x_4)) = [1] POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] POL(S2BIN2(x_1, x_2)) = [1] POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c12(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c16(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c18(x_1)) = x_1 POL(c19(x_1)) = x_1 POL(c2(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 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(cons(x_1, x_2)) = 0 POL(double(x_1)) = 0 POL(eq(x_1, x_2)) = [1] POL(false) = [1] POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (272) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_1 ---------------------------------------- (273) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) by S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) ---------------------------------------- (274) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_1 ---------------------------------------- (275) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) by S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) ---------------------------------------- (276) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_1 ---------------------------------------- (277) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c25(IF2(eq(x0, s(double(x1))), x0, cons(x1, cons(1, nil)), x3), EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) by S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), EQ(0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(eq(z0, double(x1)), s(z0), cons(x1, cons(1, nil)), x2), EQ(s(z0), bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c25(EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) ---------------------------------------- (278) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), EQ(0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(eq(z0, double(x1)), s(z0), cons(x1, cons(1, nil)), x2), EQ(s(z0), bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c25(EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), EQ(0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(eq(z0, double(x1)), s(z0), cons(x1, cons(1, nil)), x2), EQ(s(z0), bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c25(EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_1 ---------------------------------------- (279) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (280) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c25(EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c25(EQ(s(z0), bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c25(EQ(x0, bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c25(EQ(s(z0), bin2ss(x1, cons(1, nil))), BIN2S(cons(x1, cons(1, nil)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_1 ---------------------------------------- (281) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (282) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_1, c20_1 ---------------------------------------- (283) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) We considered the (Usable) Rules:none And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = x_1 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_2 POL(IF2(x_1, x_2, x_3, x_4)) = x_2 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = x_1 POL(S2BIN2(x_1, x_2)) = x_1 POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c12(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c16(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c18(x_1)) = x_1 POL(c19(x_1)) = x_1 POL(c2(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 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(cons(x_1, x_2)) = 0 POL(double(x_1)) = 0 POL(eq(x_1, x_2)) = [1] POL(false) = 0 POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = [1] POL(true) = [1] ---------------------------------------- (284) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_1, c20_1 ---------------------------------------- (285) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) We considered the (Usable) Rules: eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) eq(0, 0) -> true lt(0, s(z0)) -> true lt(s(z0), s(z1)) -> lt(z0, z1) lt(z0, 0) -> false And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = [1] POL(1) = 0 POL(BIN2S(x_1)) = x_1 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_3 POL(IF2(x_1, x_2, x_3, x_4)) = x_1 + x_2 POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] + x_1 + x_2 POL(S2BIN2(x_1, x_2)) = [1] + x_1 POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c12(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c16(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c18(x_1)) = x_1 POL(c19(x_1)) = x_1 POL(c2(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 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(cons(x_1, x_2)) = 0 POL(double(x_1)) = 0 POL(eq(x_1, x_2)) = [1] POL(false) = [1] POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (286) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_1, c20_1 ---------------------------------------- (287) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(x1))), z1)), x0, cons(x1, cons(1, cons(0, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, z1)))), BIN2S(cons(x1, cons(1, cons(0, z1))))) by S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c25(IF2(eq(x0, double(s(double(x1)))), x0, cons(x1, cons(1, cons(0, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, nil)))), BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, cons(0, x2)))), BIN2S(cons(x1, cons(1, cons(0, x2))))) ---------------------------------------- (288) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c25(IF2(eq(x0, double(s(double(x1)))), x0, cons(x1, cons(1, cons(0, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, nil)))), BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, cons(0, x2)))), BIN2S(cons(x1, cons(1, cons(0, x2))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c25(IF2(eq(x0, double(s(double(x1)))), x0, cons(x1, cons(1, cons(0, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, nil)))), BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, cons(0, x2)))), BIN2S(cons(x1, cons(1, cons(0, x2))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_1, c20_1 ---------------------------------------- (289) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (290) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, cons(0, x2)))), BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, cons(0, nil)))), BIN2S(cons(x1, cons(1, cons(0, nil))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, cons(0, x2)))), BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, cons(0, nil)))), BIN2S(cons(x1, cons(1, cons(0, nil))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_1, c20_1 ---------------------------------------- (291) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (292) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_1, c20_1, c24_1 ---------------------------------------- (293) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) We considered the (Usable) Rules:none And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = x_1 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = [1] POL(IF2(x_1, x_2, x_3, x_4)) = [1] POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] POL(S2BIN2(x_1, x_2)) = [1] POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c12(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c16(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c18(x_1)) = x_1 POL(c19(x_1)) = x_1 POL(c2(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c24(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 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(cons(x_1, x_2)) = 0 POL(double(x_1)) = 0 POL(eq(x_1, x_2)) = [1] POL(false) = 0 POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (294) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c25_3, c9_1, c21_3, c12_1, c13_1, c15_1, c16_1, c18_1, c19_1, c20_1, c24_1 ---------------------------------------- (295) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(1, z1))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, z1)))), BIN2S(cons(x1, cons(1, cons(1, z1))))) by S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, cons(1, x2)))), BIN2S(cons(x1, cons(1, cons(1, x2))))) ---------------------------------------- (296) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, cons(1, x2)))), BIN2S(cons(x1, cons(1, cons(1, x2))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c25(EQ(x0, bin2ss(x1, cons(1, cons(1, x2)))), BIN2S(cons(x1, cons(1, cons(1, x2))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c25_3, c16_1, c18_1, c19_1, c20_1, c24_1 ---------------------------------------- (297) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (298) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c25_3, c16_1, c18_1, c19_1, c20_1, c24_1, c26_1 ---------------------------------------- (299) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) We considered the (Usable) Rules:none And the Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) The order we found is given by the following interpretation: Polynomial interpretation : POL(0) = 0 POL(1) = 0 POL(BIN2S(x_1)) = x_1 POL(BIN2SS(x_1, x_2)) = 0 POL(EQ(x_1, x_2)) = 0 POL(HALF(x_1)) = 0 POL(IF1(x_1, x_2, x_3, x_4)) = [1] POL(IF2(x_1, x_2, x_3, x_4)) = [1] POL(LOG(x_1)) = 0 POL(LT(x_1, x_2)) = 0 POL(S2BIN1(x_1, x_2, x_3)) = [1] POL(S2BIN2(x_1, x_2)) = [1] POL(bin2ss(x_1, x_2)) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c12(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c14(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c16(x_1)) = x_1 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c18(x_1)) = x_1 POL(c19(x_1)) = x_1 POL(c2(x_1)) = x_1 POL(c20(x_1)) = x_1 POL(c21(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c24(x_1)) = x_1 POL(c25(x_1)) = x_1 POL(c25(x_1, x_2)) = x_1 + x_2 POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(c26(x_1)) = x_1 POL(c27(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(c4(x_1)) = x_1 POL(c5(x_1)) = x_1 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(cons(x_1, x_2)) = 0 POL(double(x_1)) = 0 POL(eq(x_1, x_2)) = [1] POL(false) = 0 POL(half(x_1)) = 0 POL(log(x_1)) = 0 POL(lt(x_1, x_2)) = [1] POL(more(x_1)) = [1] + x_1 POL(nil) = 0 POL(s(x_1)) = 0 POL(true) = [1] ---------------------------------------- (300) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c25_3, c16_1, c18_1, c19_1, c20_1, c24_1, c26_1 ---------------------------------------- (301) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) by S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c9(EQ(x0, bin2ss(s(double(z0)), z1))) ---------------------------------------- (302) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c9(EQ(x0, bin2ss(s(double(z0)), z1))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c25_3, c16_1, c18_1, c19_1, c20_1, c24_1, c26_1 ---------------------------------------- (303) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c2(EQ(x0, bin2ss(double(z0), z1))) by S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c2(EQ(x0, double(x1))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c2(EQ(x0, bin2ss(double(double(x1)), z1))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c2(EQ(x0, bin2ss(s(double(double(x1))), z1))) ---------------------------------------- (304) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c9(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c2(EQ(x0, double(x1))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c2(EQ(x0, bin2ss(double(double(x1)), z1))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c2(EQ(x0, bin2ss(s(double(double(x1))), z1))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LT(x1, s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(EQ(x0, bin2ss(x1, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(EQ(x0, bin2ss(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(EQ(x0, bin2ss(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c25_3, c16_1, c18_1, c19_1, c20_1, c24_1, c26_1 ---------------------------------------- (305) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c2(EQ(x0, double(x1))) ---------------------------------------- (306) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c9(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c2(EQ(x0, bin2ss(double(double(x1)), z1))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c2(EQ(x0, bin2ss(s(double(double(x1))), z1))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c25_3, c16_1, c18_1, c19_1, c20_1, c24_1, c26_1 ---------------------------------------- (307) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c2(EQ(x0, bin2ss(s(double(z0)), z1))) by S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c2(EQ(x0, s(double(x1)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c2(EQ(x0, bin2ss(double(s(double(x1))), z1))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c2(EQ(x0, bin2ss(s(double(s(double(x1)))), z1))) ---------------------------------------- (308) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c9(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c2(EQ(x0, bin2ss(double(double(x1)), z1))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c2(EQ(x0, bin2ss(s(double(double(x1))), z1))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c2(EQ(x0, s(double(x1)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c2(EQ(x0, bin2ss(double(s(double(x1))), z1))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c2(EQ(x0, bin2ss(s(double(s(double(x1)))), z1))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c25_3, c16_1, c18_1, c19_1, c20_1, c24_1, c26_1 ---------------------------------------- (309) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: S2BIN2(x0, cons(cons(x1, cons(1, nil)), x3)) -> c2(EQ(x0, s(double(x1)))) ---------------------------------------- (310) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c9(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c2(EQ(x0, bin2ss(double(double(x1)), z1))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c2(EQ(x0, bin2ss(s(double(double(x1))), z1))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c2(EQ(x0, bin2ss(double(s(double(x1))), z1))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c2(EQ(x0, bin2ss(s(double(s(double(x1)))), z1))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c25_3, c16_1, c18_1, c19_1, c20_1, c24_1, c26_1 ---------------------------------------- (311) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) by S2BIN1(s(s(s(s(z0)))), s(z1), z2) -> c21(IF1(lt(z1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(z1), z2), LT(s(z1), s(log(s(half(s(s(z0))))))), LOG(s(s(s(s(z0)))))) ---------------------------------------- (312) Obligation: Complexity Dependency Tuples Problem Rules: more(nil) -> nil more(cons(z0, z1)) -> cons(cons(0, z0), cons(cons(1, z0), cons(z0, z1))) half(s(s(z0))) -> s(half(z0)) half(0) -> 0 half(s(0)) -> 0 lt(0, s(z0)) -> true lt(z0, 0) -> false lt(s(z0), s(z1)) -> lt(z0, z1) log(0) -> 0 log(s(0)) -> 0 log(s(s(z0))) -> s(log(half(s(s(z0))))) eq(0, 0) -> true eq(0, s(z0)) -> false eq(s(z0), 0) -> false eq(s(z0), s(z1)) -> eq(z0, z1) bin2ss(z0, nil) -> z0 bin2ss(z0, cons(0, z1)) -> bin2ss(double(z0), z1) bin2ss(z0, cons(1, z1)) -> bin2ss(s(double(z0)), z1) Tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN2(x0, cons(cons(z0, nil), x3)) -> c2(EQ(x0, z0)) S2BIN1(s(s(s(s(z0)))), s(x1), x2) -> c21(IF1(lt(x1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(s(z0)))))))), LOG(s(s(s(s(z0)))))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c13(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(z0)), x1, x2) -> c4(LT(x1, s(log(s(half(z0)))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(z0, nil), x2)) -> c5(EQ(x0, z0)) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(0, z1)), x3)) -> c7(EQ(x0, bin2ss(double(z0), z1))) S2BIN2(x0, cons(cons(z0, cons(0, nil)), x2)) -> c7(EQ(x0, bin2ss(double(z0), nil))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(z0, cons(1, z1)), x3)) -> c9(EQ(x0, bin2ss(s(double(z0)), z1))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, z1))), x3)) -> c2(EQ(x0, bin2ss(double(double(x1)), z1))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, z1))), x3)) -> c2(EQ(x0, bin2ss(s(double(double(x1))), z1))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, z1))), x3)) -> c2(EQ(x0, bin2ss(double(s(double(x1))), z1))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, z1))), x3)) -> c2(EQ(x0, bin2ss(s(double(s(double(x1)))), z1))) S2BIN1(s(s(s(s(z0)))), s(z1), z2) -> c21(IF1(lt(z1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(z1), z2), LT(s(z1), s(log(s(half(s(s(z0))))))), LOG(s(s(s(s(z0)))))) S tuples: LT(s(z0), s(z1)) -> c6(LT(z0, z1)) BIN2S(cons(z0, z1)) -> c8(BIN2SS(z0, z1)) BIN2SS(z0, cons(0, z1)) -> c10(BIN2SS(double(z0), z1)) BIN2SS(z0, cons(1, z1)) -> c11(BIN2SS(s(double(z0)), z1)) HALF(s(s(z0))) -> c14(HALF(z0)) IF2(false, z0, z1, z2) -> c27(S2BIN2(z0, z2)) IF1(true, z0, z1, z2) -> c22(S2BIN1(z0, s(z1), more(z2))) LOG(s(s(s(s(z0))))) -> c17(LOG(s(s(half(z0)))), HALF(s(s(s(s(z0)))))) LOG(s(s(x0))) -> c17(HALF(s(s(x0)))) LOG(s(s(0))) -> c17(HALF(s(s(0)))) LOG(s(s(s(0)))) -> c17(HALF(s(s(s(0))))) EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1))) S2BIN2(s(x0), cons(nil, x1)) -> c25(IF2(false, s(x0), nil, x1)) S2BIN2(0, cons(cons(s(z0), nil), x2)) -> c25(IF2(false, 0, cons(s(z0), nil), x2), BIN2S(cons(s(z0), nil))) S2BIN1(s(s(0)), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(0)), s(x1), x2), LT(s(x1), s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), s(x1), x2) -> c21(IF1(lt(x1, log(s(0))), s(s(s(0))), s(x1), x2), LT(s(x1), s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c21(IF1(lt(x1, s(s(log(half(s(s(half(x0)))))))), s(s(s(s(x0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(x0)))))))), LOG(s(s(s(s(x0)))))) S2BIN1(s(s(s(s(s(s(z0)))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(s(half(z0))))))), s(s(s(s(s(s(z0)))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(s(z0)))))))))), LOG(s(s(s(s(s(s(z0)))))))) S2BIN1(s(s(s(s(0)))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(0)))), x1, x2), LT(x1, s(log(half(s(s(s(s(0)))))))), LOG(s(s(s(s(0)))))) S2BIN1(s(s(s(s(s(0))))), x1, x2) -> c21(IF1(lt(x1, s(log(s(s(0))))), s(s(s(s(s(0))))), x1, x2), LT(x1, s(log(half(s(s(s(s(s(0))))))))), LOG(s(s(s(s(s(0))))))) S2BIN1(s(s(0)), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(0)), x0, x1), LT(x0, s(log(half(s(s(0)))))), LOG(s(s(0)))) S2BIN1(s(s(s(0))), x0, x1) -> c21(IF1(lt(x0, s(0)), s(s(s(0))), x0, x1), LT(x0, s(log(half(s(s(s(0))))))), LOG(s(s(s(0))))) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1)) S2BIN2(s(x0), cons(cons(0, nil), x1)) -> c25(IF2(false, s(x0), cons(0, nil), x1), BIN2S(cons(0, nil))) S2BIN2(s(s(z0)), cons(cons(s(0), nil), x2)) -> c25(IF2(false, s(s(z0)), cons(s(0), nil), x2), EQ(s(s(z0)), bin2ss(s(0), nil)), BIN2S(cons(s(0), nil))) S2BIN2(s(s(z0)), cons(cons(s(s(z1)), nil), x2)) -> c25(IF2(eq(z0, z1), s(s(z0)), cons(s(s(z1)), nil), x2), EQ(s(s(z0)), bin2ss(s(s(z1)), nil)), BIN2S(cons(s(s(z1)), nil))) S2BIN2(s(0), cons(cons(s(s(z0)), nil), x2)) -> c25(IF2(false, s(0), cons(s(s(z0)), nil), x2), BIN2S(cons(s(s(z0)), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(double(x1))), z1)), x0, cons(x1, cons(0, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(double(x1)))), x0, cons(x1, cons(0, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, nil)))), BIN2S(cons(x1, cons(0, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(double(x1)))), z1)), x0, cons(x1, cons(0, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(double(x1))))), z1)), x0, cons(x1, cons(0, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(0, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(0, cons(1, cons(1, z1)))))) S2BIN2(0, cons(cons(x1, cons(1, nil)), x2)) -> c25(IF2(false, 0, cons(x1, cons(1, nil)), x2), BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(double(s(double(x1)))), z1)), x0, cons(x1, cons(1, cons(0, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(0, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(0, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(0, cons(1, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, nil))), x3)) -> c25(IF2(eq(x0, s(double(s(double(x1))))), x0, cons(x1, cons(1, cons(1, nil))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, nil)))), BIN2S(cons(x1, cons(1, cons(1, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(0, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(double(s(double(s(double(x1))))), z1)), x0, cons(x1, cons(1, cons(1, cons(0, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(0, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(0, z1)))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, cons(1, z1)))), x3)) -> c25(IF2(eq(x0, bin2ss(s(double(s(double(s(double(x1)))))), z1)), x0, cons(x1, cons(1, cons(1, cons(1, z1)))), x3), EQ(x0, bin2ss(x1, cons(1, cons(1, cons(1, z1))))), BIN2S(cons(x1, cons(1, cons(1, cons(1, z1)))))) S2BIN1(s(s(s(s(z0)))), s(z1), z2) -> c21(IF1(lt(z1, log(s(s(half(z0))))), s(s(s(s(z0)))), s(z1), z2), LT(s(z1), s(log(s(half(s(s(z0))))))), LOG(s(s(s(s(z0)))))) K tuples: IF1(false, z0, z1, z2) -> c23(S2BIN2(z0, z2)) S2BIN1(0, z0, x1) -> c(IF1(false, 0, z0, x1)) S2BIN1(s(0), z0, x1) -> c1(IF1(false, s(0), z0, x1)) S2BIN2(x0, cons(cons(x1, x2), x3)) -> c2(BIN2S(cons(x1, x2))) S2BIN1(s(s(x0)), x1, x2) -> c4(LOG(s(s(x0)))) S2BIN2(0, cons(cons(0, nil), x2)) -> c25(BIN2S(cons(0, nil))) S2BIN2(x0, cons(cons(x1, nil), x2)) -> c5(BIN2S(cons(x1, nil))) S2BIN2(x0, cons(cons(x1, cons(0, x2)), x3)) -> c7(BIN2S(cons(x1, cons(0, x2)))) S2BIN2(x0, cons(cons(x1, cons(0, nil)), x3)) -> c7(BIN2S(cons(x1, cons(0, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, x2)), x3)) -> c9(BIN2S(cons(x1, cons(1, x2)))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LT(s(x1), s(log(half(s(s(x0))))))) S2BIN1(s(s(x0)), s(x1), x2) -> c12(LOG(s(s(x0)))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LT(x1, s(log(half(s(s(s(s(x0))))))))) S2BIN1(s(s(s(s(x0)))), x1, x2) -> c15(LOG(s(s(s(s(x0)))))) S2BIN2(s(0), cons(cons(s(0), nil), x2)) -> c25(BIN2S(cons(s(0), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(EQ(s(x0), bin2ss(s(x1), nil))) S2BIN2(s(x0), cons(cons(s(x1), nil), x2)) -> c16(BIN2S(cons(s(x1), nil))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, x2))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(EQ(x0, bin2ss(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(0, nil))), x3)) -> c18(BIN2S(cons(x1, cons(0, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(EQ(x0, bin2ss(x1, cons(0, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(0, cons(1, x2))), x3)) -> c19(BIN2S(cons(x1, cons(0, cons(1, x2))))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(s(z0), bin2ss(x1, cons(1, nil)))) S2BIN2(s(z0), cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(EQ(x0, bin2ss(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, nil)), x2)) -> c20(BIN2S(cons(x1, cons(1, nil)))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, x2))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(EQ(x0, bin2ss(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(0, nil))), x3)) -> c24(BIN2S(cons(x1, cons(1, cons(0, nil))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(EQ(x0, bin2ss(x1, cons(1, cons(1, x2))))) S2BIN2(x0, cons(cons(x1, cons(1, cons(1, x2))), x3)) -> c26(BIN2S(cons(x1, cons(1, cons(1, x2))))) Defined Rule Symbols: more_1, half_1, lt_2, log_1, eq_2, bin2ss_2 Defined Pair Symbols: LT_2, BIN2S_1, BIN2SS_2, HALF_1, IF1_4, IF2_4, LOG_1, S2BIN1_3, S2BIN2_2, EQ_2 Compound Symbols: c6_1, c8_1, c10_1, c11_1, c14_1, c23_1, c27_1, c22_1, c17_2, c17_1, c_1, c1_1, c2_1, c3_1, c25_1, c4_1, c25_2, c5_1, c7_1, c9_1, c21_3, c12_1, c13_1, c15_1, c25_3, c16_1, c18_1, c19_1, c20_1, c24_1, c26_1