KILLED proof of input_g4h7EUushs.trs # AProVE Commit ID: aff8ecad908e01718a4c36e68d2e55d5e0f16e15 fuhs 20220216 unpublished The Runtime Complexity (parallel-innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF). (0) CpxRelTRS (1) SInnermostTerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 210 ms] (2) CpxRelTRS (3) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms] (4) CpxRelTRS (5) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms] (6) CpxTRS (7) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms] (8) CpxWeightedTrs (9) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms] (10) CpxTypedWeightedTrs (11) CompletionProof [UPPER BOUND(ID), 0 ms] (12) CpxTypedWeightedCompleteTrs (13) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (14) CpxTypedWeightedCompleteTrs (15) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 10 ms] (16) CpxRNTS (17) InliningProof [UPPER BOUND(ID), 1112 ms] (18) CpxRNTS (19) SimplificationProof [BOTH BOUNDS(ID, ID), 13 ms] (20) CpxRNTS (21) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms] (22) CpxRNTS (23) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (24) CpxRNTS (25) IntTrsBoundProof [UPPER BOUND(ID), 1035 ms] (26) CpxRNTS (27) IntTrsBoundProof [UPPER BOUND(ID), 89 ms] (28) CpxRNTS (29) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (30) CpxRNTS (31) IntTrsBoundProof [UPPER BOUND(ID), 224 ms] (32) CpxRNTS (33) IntTrsBoundProof [UPPER BOUND(ID), 43 ms] (34) CpxRNTS (35) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (36) CpxRNTS (37) IntTrsBoundProof [UPPER BOUND(ID), 159 ms] (38) CpxRNTS (39) IntTrsBoundProof [UPPER BOUND(ID), 3 ms] (40) CpxRNTS (41) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (42) CpxRNTS (43) IntTrsBoundProof [UPPER BOUND(ID), 570 ms] (44) CpxRNTS (45) IntTrsBoundProof [UPPER BOUND(ID), 136 ms] (46) CpxRNTS (47) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (48) CpxRNTS (49) IntTrsBoundProof [UPPER BOUND(ID), 2232 ms] (50) CpxRNTS (51) IntTrsBoundProof [UPPER BOUND(ID), 878 ms] (52) CpxRNTS (53) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (54) CpxRNTS (55) IntTrsBoundProof [UPPER BOUND(ID), 631 ms] (56) CpxRNTS (57) IntTrsBoundProof [UPPER BOUND(ID), 190 ms] (58) CpxRNTS (59) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (60) CpxRNTS (61) IntTrsBoundProof [UPPER BOUND(ID), 3887 ms] (62) CpxRNTS (63) IntTrsBoundProof [UPPER BOUND(ID), 594 ms] (64) CpxRNTS (65) CompletionProof [UPPER BOUND(ID), 0 ms] (66) CpxTypedWeightedCompleteTrs (67) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms] (68) CpxRNTS (69) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms] (70) CdtProblem (71) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (72) CdtProblem (73) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (74) CdtProblem (75) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 1104 ms] (76) CdtProblem (77) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 1129 ms] (78) CdtProblem (79) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 845 ms] (80) CdtProblem (81) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (82) CdtProblem (83) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (84) CdtProblem (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (86) CdtProblem (87) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (88) CdtProblem (89) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (90) CdtProblem (91) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (92) CdtProblem (93) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (94) CdtProblem (95) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 79 ms] (96) CdtProblem (97) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (98) CdtProblem (99) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 108 ms] (100) CdtProblem (101) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 187 ms] (102) CdtProblem (103) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (104) CdtProblem (105) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 94 ms] (106) CdtProblem (107) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (108) CdtProblem (109) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 121 ms] (110) CdtProblem (111) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (112) CdtProblem (113) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 128 ms] (114) CdtProblem (115) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 197 ms] (116) CdtProblem (117) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (118) CdtProblem (119) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (120) CdtProblem (121) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (122) CdtProblem (123) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (124) CdtProblem (125) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (126) CdtProblem (127) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (128) CdtProblem (129) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (130) CdtProblem (131) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (132) CdtProblem (133) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (134) CdtProblem (135) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (136) CdtProblem (137) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (138) CdtProblem (139) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (140) CdtProblem (141) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (142) CdtProblem (143) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms] (144) CdtProblem (145) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (146) CdtProblem (147) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (148) CdtProblem (149) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (150) CdtProblem (151) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (152) CdtProblem (153) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (154) CdtProblem (155) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (156) CdtProblem (157) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (158) CdtProblem (159) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (160) CdtProblem (161) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (162) CdtProblem (163) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (164) CdtProblem (165) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (166) CdtProblem (167) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (168) CdtProblem (169) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (170) CdtProblem (171) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (172) CdtProblem (173) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (174) CdtProblem (175) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (176) CdtProblem (177) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (178) CdtProblem (179) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (180) CdtProblem (181) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (182) CdtProblem (183) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (184) CdtProblem (185) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (186) CdtProblem (187) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (188) CdtProblem (189) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (190) CdtProblem (191) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (192) CdtProblem (193) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 1 ms] (194) CdtProblem (195) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (196) CdtProblem ---------------------------------------- (0) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: #less(@x, @y) -> #cklt(#compare(@x, @y)) merge(@l1, @l2) -> merge#1(@l1, @l2) merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) merge#1(nil, @l2) -> @l2 merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys) merge#2(nil, @x, @xs) -> ::(@x, @xs) merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) mergesort(@l) -> mergesort#1(@l) mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) mergesort#1(nil) -> nil mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs')))) mergesort#2(nil, @x1) -> ::(@x1, nil) mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2)) msplit(@l) -> msplit#1(@l) msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2) msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) The (relative) TRS S consists of the following rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(@y)) -> #GT #compare(#0, #pos(@y)) -> #LT #compare(#0, #s(@y)) -> #LT #compare(#neg(@x), #0) -> #LT #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) #compare(#neg(@x), #pos(@y)) -> #LT #compare(#pos(@x), #0) -> #GT #compare(#pos(@x), #neg(@y)) -> #GT #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) #compare(#s(@x), #0) -> #GT #compare(#s(@x), #s(@y)) -> #compare(@x, @y) Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (1) SInnermostTerminationProof (BOTH CONCRETE BOUNDS(ID, ID)) proved innermost termination of relative rules ---------------------------------------- (2) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: #less(@x, @y) -> #cklt(#compare(@x, @y)) merge(@l1, @l2) -> merge#1(@l1, @l2) merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) merge#1(nil, @l2) -> @l2 merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys) merge#2(nil, @x, @xs) -> ::(@x, @xs) merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) mergesort(@l) -> mergesort#1(@l) mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) mergesort#1(nil) -> nil mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs')))) mergesort#2(nil, @x1) -> ::(@x1, nil) mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2)) msplit(@l) -> msplit#1(@l) msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2) msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) The (relative) TRS S consists of the following rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(@y)) -> #GT #compare(#0, #pos(@y)) -> #LT #compare(#0, #s(@y)) -> #LT #compare(#neg(@x), #0) -> #LT #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) #compare(#neg(@x), #pos(@y)) -> #LT #compare(#pos(@x), #0) -> #GT #compare(#pos(@x), #neg(@y)) -> #GT #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) #compare(#s(@x), #0) -> #GT #compare(#s(@x), #s(@y)) -> #compare(@x, @y) Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (3) RenamingProof (BOTH BOUNDS(ID, ID)) Renamed function symbols to avoid clashes with predefined symbol. ---------------------------------------- (4) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: #less(@x, @y) -> #cklt(#compare(@x, @y)) merge(@l1, @l2) -> merge#1(@l1, @l2) merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) merge#1(nil, @l2) -> @l2 merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys) merge#2(nil, @x, @xs) -> ::(@x, @xs) merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) mergesort(@l) -> mergesort#1(@l) mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) mergesort#1(nil) -> nil mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs')))) mergesort#2(nil, @x1) -> ::(@x1, nil) mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2)) msplit(@l) -> msplit#1(@l) msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2) msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) The (relative) TRS S consists of the following rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(@y)) -> #GT #compare(#0, #pos(@y)) -> #LT #compare(#0, #s(@y)) -> #LT #compare(#neg(@x), #0) -> #LT #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) #compare(#neg(@x), #pos(@y)) -> #LT #compare(#pos(@x), #0) -> #GT #compare(#pos(@x), #neg(@y)) -> #GT #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) #compare(#s(@x), #0) -> #GT #compare(#s(@x), #s(@y)) -> #compare(@x, @y) Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (5) RelTrsToTrsProof (UPPER BOUND(ID)) transformed relative TRS to TRS ---------------------------------------- (6) 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: #less(@x, @y) -> #cklt(#compare(@x, @y)) merge(@l1, @l2) -> merge#1(@l1, @l2) merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) merge#1(nil, @l2) -> @l2 merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys) merge#2(nil, @x, @xs) -> ::(@x, @xs) merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) mergesort(@l) -> mergesort#1(@l) mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) mergesort#1(nil) -> nil mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs')))) mergesort#2(nil, @x1) -> ::(@x1, nil) mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2)) msplit(@l) -> msplit#1(@l) msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2) msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(@y)) -> #GT #compare(#0, #pos(@y)) -> #LT #compare(#0, #s(@y)) -> #LT #compare(#neg(@x), #0) -> #LT #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) #compare(#neg(@x), #pos(@y)) -> #LT #compare(#pos(@x), #0) -> #GT #compare(#pos(@x), #neg(@y)) -> #GT #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) #compare(#s(@x), #0) -> #GT #compare(#s(@x), #s(@y)) -> #compare(@x, @y) S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (7) RelTrsToWeightedTrsProof (UPPER BOUND(ID)) Transformed relative TRS to weighted TRS ---------------------------------------- (8) 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: #less(@x, @y) -> #cklt(#compare(@x, @y)) [1] merge(@l1, @l2) -> merge#1(@l1, @l2) [1] merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) [1] merge#1(nil, @l2) -> @l2 [1] merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys) [1] merge#2(nil, @x, @xs) -> ::(@x, @xs) [1] merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) [1] merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) [1] mergesort(@l) -> mergesort#1(@l) [1] mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) [1] mergesort#1(nil) -> nil [1] mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs')))) [1] mergesort#2(nil, @x1) -> ::(@x1, nil) [1] mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2)) [1] msplit(@l) -> msplit#1(@l) [1] msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) [1] msplit#1(nil) -> tuple#2(nil, nil) [1] msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2) [1] msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) [1] msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) [1] #cklt(#EQ) -> #false [0] #cklt(#GT) -> #false [0] #cklt(#LT) -> #true [0] #compare(#0, #0) -> #EQ [0] #compare(#0, #neg(@y)) -> #GT [0] #compare(#0, #pos(@y)) -> #LT [0] #compare(#0, #s(@y)) -> #LT [0] #compare(#neg(@x), #0) -> #LT [0] #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0] #compare(#neg(@x), #pos(@y)) -> #LT [0] #compare(#pos(@x), #0) -> #GT [0] #compare(#pos(@x), #neg(@y)) -> #GT [0] #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0] #compare(#s(@x), #0) -> #GT [0] #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0] Rewrite Strategy: INNERMOST ---------------------------------------- (9) TypeInferenceProof (BOTH BOUNDS(ID, ID)) Infered types. ---------------------------------------- (10) Obligation: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: #less(@x, @y) -> #cklt(#compare(@x, @y)) [1] merge(@l1, @l2) -> merge#1(@l1, @l2) [1] merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) [1] merge#1(nil, @l2) -> @l2 [1] merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys) [1] merge#2(nil, @x, @xs) -> ::(@x, @xs) [1] merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) [1] merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) [1] mergesort(@l) -> mergesort#1(@l) [1] mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) [1] mergesort#1(nil) -> nil [1] mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs')))) [1] mergesort#2(nil, @x1) -> ::(@x1, nil) [1] mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2)) [1] msplit(@l) -> msplit#1(@l) [1] msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) [1] msplit#1(nil) -> tuple#2(nil, nil) [1] msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2) [1] msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) [1] msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) [1] #cklt(#EQ) -> #false [0] #cklt(#GT) -> #false [0] #cklt(#LT) -> #true [0] #compare(#0, #0) -> #EQ [0] #compare(#0, #neg(@y)) -> #GT [0] #compare(#0, #pos(@y)) -> #LT [0] #compare(#0, #s(@y)) -> #LT [0] #compare(#neg(@x), #0) -> #LT [0] #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0] #compare(#neg(@x), #pos(@y)) -> #LT [0] #compare(#pos(@x), #0) -> #GT [0] #compare(#pos(@x), #neg(@y)) -> #GT [0] #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0] #compare(#s(@x), #0) -> #GT [0] #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0] The TRS has the following type information: #less :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true #cklt :: #EQ:#GT:#LT -> #false:#true #compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT merge :: :::nil -> :::nil -> :::nil merge#1 :: :::nil -> :::nil -> :::nil :: :: #0:#neg:#pos:#s -> :::nil -> :::nil merge#2 :: :::nil -> #0:#neg:#pos:#s -> :::nil -> :::nil nil :: :::nil merge#3 :: #false:#true -> #0:#neg:#pos:#s -> :::nil -> #0:#neg:#pos:#s -> :::nil -> :::nil #false :: #false:#true #true :: #false:#true mergesort :: :::nil -> :::nil mergesort#1 :: :::nil -> :::nil mergesort#2 :: :::nil -> #0:#neg:#pos:#s -> :::nil mergesort#3 :: tuple#2 -> :::nil msplit :: :::nil -> tuple#2 tuple#2 :: :::nil -> :::nil -> tuple#2 msplit#1 :: :::nil -> tuple#2 msplit#2 :: :::nil -> #0:#neg:#pos:#s -> tuple#2 msplit#3 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2 #EQ :: #EQ:#GT:#LT #GT :: #EQ:#GT:#LT #LT :: #EQ:#GT:#LT #0 :: #0:#neg:#pos:#s #neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s #pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s #s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s Rewrite Strategy: INNERMOST ---------------------------------------- (11) 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: none (c) The following functions are completely defined: msplit_1 mergesort_1 #less_2 msplit#1_1 mergesort#1_1 msplit#2_2 mergesort#2_2 mergesort#3_1 merge_2 msplit#3_3 merge#1_2 merge#2_3 merge#3_5 #cklt_1 #compare_2 Due to the following rules being added: #cklt(v0) -> null_#cklt [0] #compare(v0, v1) -> null_#compare [0] mergesort#3(v0) -> nil [0] msplit#3(v0, v1, v2) -> const [0] merge#3(v0, v1, v2, v3, v4) -> nil [0] And the following fresh constants: null_#cklt, null_#compare, const ---------------------------------------- (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: #less(@x, @y) -> #cklt(#compare(@x, @y)) [1] merge(@l1, @l2) -> merge#1(@l1, @l2) [1] merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) [1] merge#1(nil, @l2) -> @l2 [1] merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys) [1] merge#2(nil, @x, @xs) -> ::(@x, @xs) [1] merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) [1] merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) [1] mergesort(@l) -> mergesort#1(@l) [1] mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) [1] mergesort#1(nil) -> nil [1] mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs')))) [1] mergesort#2(nil, @x1) -> ::(@x1, nil) [1] mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2)) [1] msplit(@l) -> msplit#1(@l) [1] msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) [1] msplit#1(nil) -> tuple#2(nil, nil) [1] msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2) [1] msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) [1] msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) [1] #cklt(#EQ) -> #false [0] #cklt(#GT) -> #false [0] #cklt(#LT) -> #true [0] #compare(#0, #0) -> #EQ [0] #compare(#0, #neg(@y)) -> #GT [0] #compare(#0, #pos(@y)) -> #LT [0] #compare(#0, #s(@y)) -> #LT [0] #compare(#neg(@x), #0) -> #LT [0] #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0] #compare(#neg(@x), #pos(@y)) -> #LT [0] #compare(#pos(@x), #0) -> #GT [0] #compare(#pos(@x), #neg(@y)) -> #GT [0] #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0] #compare(#s(@x), #0) -> #GT [0] #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0] #cklt(v0) -> null_#cklt [0] #compare(v0, v1) -> null_#compare [0] mergesort#3(v0) -> nil [0] msplit#3(v0, v1, v2) -> const [0] merge#3(v0, v1, v2, v3, v4) -> nil [0] The TRS has the following type information: #less :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true:null_#cklt #cklt :: #EQ:#GT:#LT:null_#compare -> #false:#true:null_#cklt #compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT:null_#compare merge :: :::nil -> :::nil -> :::nil merge#1 :: :::nil -> :::nil -> :::nil :: :: #0:#neg:#pos:#s -> :::nil -> :::nil merge#2 :: :::nil -> #0:#neg:#pos:#s -> :::nil -> :::nil nil :: :::nil merge#3 :: #false:#true:null_#cklt -> #0:#neg:#pos:#s -> :::nil -> #0:#neg:#pos:#s -> :::nil -> :::nil #false :: #false:#true:null_#cklt #true :: #false:#true:null_#cklt mergesort :: :::nil -> :::nil mergesort#1 :: :::nil -> :::nil mergesort#2 :: :::nil -> #0:#neg:#pos:#s -> :::nil mergesort#3 :: tuple#2:const -> :::nil msplit :: :::nil -> tuple#2:const tuple#2 :: :::nil -> :::nil -> tuple#2:const msplit#1 :: :::nil -> tuple#2:const msplit#2 :: :::nil -> #0:#neg:#pos:#s -> tuple#2:const msplit#3 :: tuple#2:const -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2:const #EQ :: #EQ:#GT:#LT:null_#compare #GT :: #EQ:#GT:#LT:null_#compare #LT :: #EQ:#GT:#LT:null_#compare #0 :: #0:#neg:#pos:#s #neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s #pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s #s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s null_#cklt :: #false:#true:null_#cklt null_#compare :: #EQ:#GT:#LT:null_#compare const :: tuple#2:const Rewrite Strategy: INNERMOST ---------------------------------------- (13) NarrowingProof (BOTH BOUNDS(ID, ID)) Narrowed the inner basic terms of all right-hand sides by a single narrowing step. ---------------------------------------- (14) 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: #less(#0, #0) -> #cklt(#EQ) [1] #less(#0, #neg(@y')) -> #cklt(#GT) [1] #less(#0, #pos(@y'')) -> #cklt(#LT) [1] #less(#0, #s(@y1)) -> #cklt(#LT) [1] #less(#neg(@x'), #0) -> #cklt(#LT) [1] #less(#neg(@x''), #neg(@y2)) -> #cklt(#compare(@y2, @x'')) [1] #less(#neg(@x3), #pos(@y3)) -> #cklt(#LT) [1] #less(#pos(@x4), #0) -> #cklt(#GT) [1] #less(#pos(@x5), #neg(@y4)) -> #cklt(#GT) [1] #less(#pos(@x6), #pos(@y5)) -> #cklt(#compare(@x6, @y5)) [1] #less(#s(@x7), #0) -> #cklt(#GT) [1] #less(#s(@x8), #s(@y6)) -> #cklt(#compare(@x8, @y6)) [1] #less(@x, @y) -> #cklt(null_#compare) [1] merge(@l1, @l2) -> merge#1(@l1, @l2) [1] merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) [1] merge#1(nil, @l2) -> @l2 [1] merge#2(::(@y, @ys), @x, @xs) -> merge#3(#cklt(#compare(@x, @y)), @x, @xs, @y, @ys) [2] merge#2(nil, @x, @xs) -> ::(@x, @xs) [1] merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) [1] merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) [1] mergesort(@l) -> mergesort#1(@l) [1] mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) [1] mergesort#1(nil) -> nil [1] mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit#1(::(@x1, ::(@x2, @xs')))) [2] mergesort#2(nil, @x1) -> ::(@x1, nil) [1] mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort#1(@l1), mergesort#1(@l2)) [3] msplit(@l) -> msplit#1(@l) [1] msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) [1] msplit#1(nil) -> tuple#2(nil, nil) [1] msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit#1(@xs'), @x1, @x2) [2] msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) [1] msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) [1] #cklt(#EQ) -> #false [0] #cklt(#GT) -> #false [0] #cklt(#LT) -> #true [0] #compare(#0, #0) -> #EQ [0] #compare(#0, #neg(@y)) -> #GT [0] #compare(#0, #pos(@y)) -> #LT [0] #compare(#0, #s(@y)) -> #LT [0] #compare(#neg(@x), #0) -> #LT [0] #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0] #compare(#neg(@x), #pos(@y)) -> #LT [0] #compare(#pos(@x), #0) -> #GT [0] #compare(#pos(@x), #neg(@y)) -> #GT [0] #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0] #compare(#s(@x), #0) -> #GT [0] #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0] #cklt(v0) -> null_#cklt [0] #compare(v0, v1) -> null_#compare [0] mergesort#3(v0) -> nil [0] msplit#3(v0, v1, v2) -> const [0] merge#3(v0, v1, v2, v3, v4) -> nil [0] The TRS has the following type information: #less :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true:null_#cklt #cklt :: #EQ:#GT:#LT:null_#compare -> #false:#true:null_#cklt #compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT:null_#compare merge :: :::nil -> :::nil -> :::nil merge#1 :: :::nil -> :::nil -> :::nil :: :: #0:#neg:#pos:#s -> :::nil -> :::nil merge#2 :: :::nil -> #0:#neg:#pos:#s -> :::nil -> :::nil nil :: :::nil merge#3 :: #false:#true:null_#cklt -> #0:#neg:#pos:#s -> :::nil -> #0:#neg:#pos:#s -> :::nil -> :::nil #false :: #false:#true:null_#cklt #true :: #false:#true:null_#cklt mergesort :: :::nil -> :::nil mergesort#1 :: :::nil -> :::nil mergesort#2 :: :::nil -> #0:#neg:#pos:#s -> :::nil mergesort#3 :: tuple#2:const -> :::nil msplit :: :::nil -> tuple#2:const tuple#2 :: :::nil -> :::nil -> tuple#2:const msplit#1 :: :::nil -> tuple#2:const msplit#2 :: :::nil -> #0:#neg:#pos:#s -> tuple#2:const msplit#3 :: tuple#2:const -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2:const #EQ :: #EQ:#GT:#LT:null_#compare #GT :: #EQ:#GT:#LT:null_#compare #LT :: #EQ:#GT:#LT:null_#compare #0 :: #0:#neg:#pos:#s #neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s #pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s #s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s null_#cklt :: #false:#true:null_#cklt null_#compare :: #EQ:#GT:#LT:null_#compare const :: tuple#2:const Rewrite Strategy: INNERMOST ---------------------------------------- (15) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID)) Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction. The constant constructors are abstracted as follows: nil => 0 #false => 1 #true => 2 #EQ => 1 #GT => 2 #LT => 3 #0 => 0 null_#cklt => 0 null_#compare => 0 const => 0 ---------------------------------------- (16) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 #compare(z, z') -{ 0 }-> #compare(@x, @y) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> #compare(@y, @x) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0 #less(z, z') -{ 1 }-> #cklt(3) :|: z' = 1 + @y'', @y'' >= 0, z = 0 #less(z, z') -{ 1 }-> #cklt(3) :|: z' = 1 + @y1, @y1 >= 0, z = 0 #less(z, z') -{ 1 }-> #cklt(3) :|: z = 1 + @x', @x' >= 0, z' = 0 #less(z, z') -{ 1 }-> #cklt(3) :|: @y3 >= 0, @x3 >= 0, z' = 1 + @y3, z = 1 + @x3 #less(z, z') -{ 1 }-> #cklt(2) :|: @y' >= 0, z' = 1 + @y', z = 0 #less(z, z') -{ 1 }-> #cklt(2) :|: z = 1 + @x4, @x4 >= 0, z' = 0 #less(z, z') -{ 1 }-> #cklt(2) :|: z = 1 + @x5, z' = 1 + @y4, @y4 >= 0, @x5 >= 0 #less(z, z') -{ 1 }-> #cklt(2) :|: z = 1 + @x7, @x7 >= 0, z' = 0 #less(z, z') -{ 1 }-> #cklt(1) :|: z = 0, z' = 0 #less(z, z') -{ 1 }-> #cklt(0) :|: z = @x, @x >= 0, z' = @y, @y >= 0 #less(z, z') -{ 1 }-> #cklt(#compare(@x6, @y5)) :|: z = 1 + @x6, z' = 1 + @y5, @y5 >= 0, @x6 >= 0 #less(z, z') -{ 1 }-> #cklt(#compare(@x8, @y6)) :|: z = 1 + @x8, @x8 >= 0, z' = 1 + @y6, @y6 >= 0 #less(z, z') -{ 1 }-> #cklt(#compare(@y2, @x'')) :|: z = 1 + @x'', z' = 1 + @y2, @y2 >= 0, @x'' >= 0 merge(z, z') -{ 1 }-> merge#1(@l1, @l2) :|: @l1 >= 0, z' = @l2, @l2 >= 0, z = @l1 merge#1(z, z') -{ 1 }-> @l2 :|: z' = @l2, @l2 >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(@l2, @x, @xs) :|: z' = @l2, @x >= 0, z = 1 + @x + @xs, @l2 >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(@x, @y)), @x, @xs, @y, @ys) :|: z = 1 + @y + @ys, @x >= 0, @xs >= 0, @y >= 0, z' = @x, z'' = @xs, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + @x + @xs :|: @x >= 0, @xs >= 0, z = 0, z' = @x, z'' = @xs merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, v4 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z2 = v4, v2 >= 0, v3 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + @x + merge(@xs, 1 + @y + @ys) :|: z = 2, @x >= 0, z1 = @y, @xs >= 0, z2 = @ys, @y >= 0, z' = @x, z'' = @xs, @ys >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + @y + merge(1 + @x + @xs, @ys) :|: @x >= 0, z = 1, z1 = @y, @xs >= 0, z2 = @ys, @y >= 0, z' = @x, z'' = @xs, @ys >= 0 mergesort(z) -{ 1 }-> mergesort#1(@l) :|: z = @l, @l >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + @x1 + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', z' = @x1, @xs' >= 0, @x1 >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + @x1 + 0 :|: z' = @x1, @x1 >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 msplit(z) -{ 1 }-> msplit#1(@l) :|: z = @l, @l >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), @x1, @x2) :|: z = 1 + @x2 + @xs', z' = @x1, @xs' >= 0, @x1 >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + @x1 + 0) + 0 :|: z' = @x1, @x1 >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + @x1 + @l1) + (1 + @x2 + @l2) :|: z' = @x1, @l1 >= 0, z = 1 + @l1 + @l2, z'' = @x2, @x1 >= 0, @l2 >= 0, @x2 >= 0 ---------------------------------------- (17) InliningProof (UPPER BOUND(ID)) Inlined the following terminating rules on right-hand sides where appropriate: msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + @x1 + @l1) + (1 + @x2 + @l2) :|: z' = @x1, @l1 >= 0, z = 1 + @l1 + @l2, z'' = @x2, @x1 >= 0, @l2 >= 0, @x2 >= 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 2 :|: z = 3 ---------------------------------------- (18) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 #compare(z, z') -{ 0 }-> #compare(@x, @y) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> #compare(@y, @x) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0 #less(z, z') -{ 1 }-> 2 :|: z' = 1 + @y'', @y'' >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' = 1 + @y1, @y1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z = 1 + @x', @x' >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: @y3 >= 0, @x3 >= 0, z' = 1 + @y3, z = 1 + @x3, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: @y' >= 0, z' = 1 + @y', z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z = 1 + @x4, @x4 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z = 1 + @x5, z' = 1 + @y4, @y4 >= 0, @x5 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z = 1 + @x7, @x7 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: @y' >= 0, z' = 1 + @y', z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' = 1 + @y'', @y'' >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' = 1 + @y1, @y1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z = 1 + @x', @x' >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: @y3 >= 0, @x3 >= 0, z' = 1 + @y3, z = 1 + @x3, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z = 1 + @x4, @x4 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z = 1 + @x5, z' = 1 + @y4, @y4 >= 0, @x5 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z = 1 + @x7, @x7 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z = @x, @x >= 0, z' = @y, @y >= 0, v0 >= 0, 0 = v0 #less(z, z') -{ 1 }-> #cklt(#compare(@x6, @y5)) :|: z = 1 + @x6, z' = 1 + @y5, @y5 >= 0, @x6 >= 0 #less(z, z') -{ 1 }-> #cklt(#compare(@x8, @y6)) :|: z = 1 + @x8, @x8 >= 0, z' = 1 + @y6, @y6 >= 0 #less(z, z') -{ 1 }-> #cklt(#compare(@y2, @x'')) :|: z = 1 + @x'', z' = 1 + @y2, @y2 >= 0, @x'' >= 0 merge(z, z') -{ 1 }-> merge#1(@l1, @l2) :|: @l1 >= 0, z' = @l2, @l2 >= 0, z = @l1 merge#1(z, z') -{ 1 }-> @l2 :|: z' = @l2, @l2 >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(@l2, @x, @xs) :|: z' = @l2, @x >= 0, z = 1 + @x + @xs, @l2 >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(@x, @y)), @x, @xs, @y, @ys) :|: z = 1 + @y + @ys, @x >= 0, @xs >= 0, @y >= 0, z' = @x, z'' = @xs, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + @x + @xs :|: @x >= 0, @xs >= 0, z = 0, z' = @x, z'' = @xs merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, v4 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z2 = v4, v2 >= 0, v3 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + @x + merge(@xs, 1 + @y + @ys) :|: z = 2, @x >= 0, z1 = @y, @xs >= 0, z2 = @ys, @y >= 0, z' = @x, z'' = @xs, @ys >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + @y + merge(1 + @x + @xs, @ys) :|: @x >= 0, z = 1, z1 = @y, @xs >= 0, z2 = @ys, @y >= 0, z' = @x, z'' = @xs, @ys >= 0 mergesort(z) -{ 1 }-> mergesort#1(@l) :|: z = @l, @l >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + @x1 + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', z' = @x1, @xs' >= 0, @x1 >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + @x1 + 0 :|: z' = @x1, @x1 >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 msplit(z) -{ 1 }-> msplit#1(@l) :|: z = @l, @l >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), @x1, @x2) :|: z = 1 + @x2 + @xs', z' = @x1, @xs' >= 0, @x1 >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + @x1 + 0) + 0 :|: z' = @x1, @x1 >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + @x1 + @l1) + (1 + @x2 + @l2) :|: z' = @x1, @l1 >= 0, z = 1 + @l1 + @l2, z'' = @x2, @x1 >= 0, @l2 >= 0, @x2 >= 0 ---------------------------------------- (19) SimplificationProof (BOTH BOUNDS(ID, ID)) Simplified the RNTS by moving equalities from the constraints into the right-hand sides. ---------------------------------------- (20) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 #less(z, z') -{ 1 }-> #cklt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(z', @y)), z', z'', @y, @ys) :|: z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 ---------------------------------------- (21) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID)) Found the following analysis order by SCC decomposition: { #compare } { msplit#3 } { #cklt } { #less } { merge#1, merge#2, merge, merge#3 } { msplit#1, msplit#2 } { mergesort#3, mergesort#1, mergesort#2 } { msplit } { mergesort } ---------------------------------------- (22) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 #less(z, z') -{ 1 }-> #cklt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(z', @y)), z', z'', @y, @ys) :|: z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {#compare}, {msplit#3}, {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} ---------------------------------------- (23) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (24) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 #less(z, z') -{ 1 }-> #cklt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(z', @y)), z', z'', @y, @ys) :|: z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {#compare}, {msplit#3}, {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} ---------------------------------------- (25) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: #compare after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 3 ---------------------------------------- (26) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 #less(z, z') -{ 1 }-> #cklt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(z', @y)), z', z'', @y, @ys) :|: z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {#compare}, {msplit#3}, {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: ?, size: O(1) [3] ---------------------------------------- (27) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: #compare after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 0 ---------------------------------------- (28) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 #less(z, z') -{ 1 }-> #cklt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(z', @y)), z', z'', @y, @ys) :|: z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {msplit#3}, {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] ---------------------------------------- (29) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (30) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 #less(z, z') -{ 1 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(s2), z', z'', @y, @ys) :|: s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {msplit#3}, {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] ---------------------------------------- (31) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: msplit#3 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 2 + z + z' + z'' ---------------------------------------- (32) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 #less(z, z') -{ 1 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(s2), z', z'', @y, @ys) :|: s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {msplit#3}, {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: ?, size: O(n^1) [2 + z + z' + z''] ---------------------------------------- (33) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: msplit#3 after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (34) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 #less(z, z') -{ 1 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(s2), z', z'', @y, @ys) :|: s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] ---------------------------------------- (35) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (36) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 #less(z, z') -{ 1 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(s2), z', z'', @y, @ys) :|: s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] ---------------------------------------- (37) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: #cklt after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 2 ---------------------------------------- (38) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 #less(z, z') -{ 1 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(s2), z', z'', @y, @ys) :|: s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: ?, size: O(1) [2] ---------------------------------------- (39) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: #cklt after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 0 ---------------------------------------- (40) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 #less(z, z') -{ 1 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(s2), z', z'', @y, @ys) :|: s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] ---------------------------------------- (41) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (42) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(s5, z', z'', @y, @ys) :|: s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] ---------------------------------------- (43) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: #less after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 2 ---------------------------------------- (44) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(s5, z', z'', @y, @ys) :|: s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] #less: runtime: ?, size: O(1) [2] ---------------------------------------- (45) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: #less after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (46) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(s5, z', z'', @y, @ys) :|: s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] #less: runtime: O(1) [1], size: O(1) [2] ---------------------------------------- (47) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (48) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(s5, z', z'', @y, @ys) :|: s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] #less: runtime: O(1) [1], size: O(1) [2] ---------------------------------------- (49) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: merge#1 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z + z' Computed SIZE bound using CoFloCo for: merge#2 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z + z' + z'' Computed SIZE bound using CoFloCo for: merge after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z + z' Computed SIZE bound using CoFloCo for: merge#3 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 2 + z' + z'' + z1 + z2 ---------------------------------------- (50) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(s5, z', z'', @y, @ys) :|: s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] #less: runtime: O(1) [1], size: O(1) [2] merge#1: runtime: ?, size: O(n^1) [z + z'] merge#2: runtime: ?, size: O(n^1) [1 + z + z' + z''] merge: runtime: ?, size: O(n^1) [z + z'] merge#3: runtime: ?, size: O(n^1) [2 + z' + z'' + z1 + z2] ---------------------------------------- (51) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: merge#1 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 14 + 5*z + 5*z' Computed RUNTIME bound using CoFloCo for: merge#2 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 18 + 5*z + 5*z' + 5*z'' Computed RUNTIME bound using CoFloCo for: merge after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 15 + 5*z + 5*z' Computed RUNTIME bound using CoFloCo for: merge#3 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 21 + 5*z' + 5*z'' + 5*z1 + 5*z2 ---------------------------------------- (52) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#2(z, z', z'') -{ 2 }-> merge#3(s5, z', z'', @y, @ys) :|: s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] #less: runtime: O(1) [1], size: O(1) [2] merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z''] merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2] ---------------------------------------- (53) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (54) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 merge(z, z') -{ 15 + 5*z + 5*z' }-> s6 :|: s6 >= 0, s6 <= z + z', z >= 0, z' >= 0 merge#1(z, z') -{ 19 + 5*@x + 5*@xs + 5*z' }-> s7 :|: s7 >= 0, s7 <= z' + @x + @xs + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#2(z, z', z'') -{ 23 + 5*@y + 5*@ys + 5*z' + 5*z'' }-> s10 :|: s10 >= 0, s10 <= z' + z'' + @y + @ys + 2, s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 21 + 5*z'' + 5*z1 + 5*z2 }-> 1 + z' + s9 :|: s9 >= 0, s9 <= z'' + (1 + z1 + z2), z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 21 + 5*z' + 5*z'' + 5*z2 }-> 1 + z1 + s8 :|: s8 >= 0, s8 <= 1 + z' + z'' + z2, z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] #less: runtime: O(1) [1], size: O(1) [2] merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z''] merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2] ---------------------------------------- (55) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: msplit#1 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + z Computed SIZE bound using CoFloCo for: msplit#2 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 2 + z + z' ---------------------------------------- (56) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 merge(z, z') -{ 15 + 5*z + 5*z' }-> s6 :|: s6 >= 0, s6 <= z + z', z >= 0, z' >= 0 merge#1(z, z') -{ 19 + 5*@x + 5*@xs + 5*z' }-> s7 :|: s7 >= 0, s7 <= z' + @x + @xs + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#2(z, z', z'') -{ 23 + 5*@y + 5*@ys + 5*z' + 5*z'' }-> s10 :|: s10 >= 0, s10 <= z' + z'' + @y + @ys + 2, s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 21 + 5*z'' + 5*z1 + 5*z2 }-> 1 + z' + s9 :|: s9 >= 0, s9 <= z'' + (1 + z1 + z2), z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 21 + 5*z' + 5*z'' + 5*z2 }-> 1 + z1 + s8 :|: s8 >= 0, s8 <= 1 + z' + z'' + z2, z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] #less: runtime: O(1) [1], size: O(1) [2] merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z''] merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2] msplit#1: runtime: ?, size: O(n^1) [1 + z] msplit#2: runtime: ?, size: O(n^1) [2 + z + z'] ---------------------------------------- (57) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using KoAT for: msplit#1 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 2 + 4*z Computed RUNTIME bound using CoFloCo for: msplit#2 after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 1 + 4*z ---------------------------------------- (58) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 merge(z, z') -{ 15 + 5*z + 5*z' }-> s6 :|: s6 >= 0, s6 <= z + z', z >= 0, z' >= 0 merge#1(z, z') -{ 19 + 5*@x + 5*@xs + 5*z' }-> s7 :|: s7 >= 0, s7 <= z' + @x + @xs + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#2(z, z', z'') -{ 23 + 5*@y + 5*@ys + 5*z' + 5*z'' }-> s10 :|: s10 >= 0, s10 <= z' + z'' + @y + @ys + 2, s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 21 + 5*z'' + 5*z1 + 5*z2 }-> 1 + z' + s9 :|: s9 >= 0, s9 <= z'' + (1 + z1 + z2), z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 21 + 5*z' + 5*z'' + 5*z2 }-> 1 + z1 + s8 :|: s8 >= 0, s8 <= 1 + z' + z'' + z2, z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] #less: runtime: O(1) [1], size: O(1) [2] merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z''] merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2] msplit#1: runtime: O(n^1) [2 + 4*z], size: O(n^1) [1 + z] msplit#2: runtime: O(n^1) [1 + 4*z], size: O(n^1) [2 + z + z'] ---------------------------------------- (59) ResultPropagationProof (UPPER BOUND(ID)) Applied inner abstraction using the recently inferred runtime/size bounds where possible. ---------------------------------------- (60) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 merge(z, z') -{ 15 + 5*z + 5*z' }-> s6 :|: s6 >= 0, s6 <= z + z', z >= 0, z' >= 0 merge#1(z, z') -{ 19 + 5*@x + 5*@xs + 5*z' }-> s7 :|: s7 >= 0, s7 <= z' + @x + @xs + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#2(z, z', z'') -{ 23 + 5*@y + 5*@ys + 5*z' + 5*z'' }-> s10 :|: s10 >= 0, s10 <= z' + z'' + @y + @ys + 2, s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 21 + 5*z'' + 5*z1 + 5*z2 }-> 1 + z' + s9 :|: s9 >= 0, s9 <= z'' + (1 + z1 + z2), z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 21 + 5*z' + 5*z'' + 5*z2 }-> 1 + z1 + s8 :|: s8 >= 0, s8 <= 1 + z' + z'' + z2, z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 12 + 4*@x2 + 4*@xs' + 4*z' }-> mergesort#3(s11) :|: s11 >= 0, s11 <= 1 + z' + (1 + @x2 + @xs') + 1, z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 3 + 4*z }-> s12 :|: s12 >= 0, s12 <= z + 1, z >= 0 msplit#1(z) -{ 2 + 4*@xs }-> s13 :|: s13 >= 0, s13 <= @xs + @x1 + 2, @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 5 + 4*@xs' }-> s15 :|: s14 >= 0, s14 <= @xs' + 1, s15 >= 0, s15 <= s14 + z' + @x2 + 2, z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] #less: runtime: O(1) [1], size: O(1) [2] merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z''] merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2] msplit#1: runtime: O(n^1) [2 + 4*z], size: O(n^1) [1 + z] msplit#2: runtime: O(n^1) [1 + 4*z], size: O(n^1) [2 + z + z'] ---------------------------------------- (61) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: mergesort#3 after applying outer abstraction to obtain an ITS, resulting in: O(n^2) with polynomial bound: 12 + 9*z + z^2 Computed SIZE bound using KoAT for: mergesort#1 after applying outer abstraction to obtain an ITS, resulting in: O(n^2) with polynomial bound: 35 + 27*z + 4*z^2 Computed SIZE bound using KoAT for: mergesort#2 after applying outer abstraction to obtain an ITS, resulting in: O(n^2) with polynomial bound: 35 + 13*z + 2*z*z' + z^2 + 14*z' + z'^2 ---------------------------------------- (62) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 merge(z, z') -{ 15 + 5*z + 5*z' }-> s6 :|: s6 >= 0, s6 <= z + z', z >= 0, z' >= 0 merge#1(z, z') -{ 19 + 5*@x + 5*@xs + 5*z' }-> s7 :|: s7 >= 0, s7 <= z' + @x + @xs + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#2(z, z', z'') -{ 23 + 5*@y + 5*@ys + 5*z' + 5*z'' }-> s10 :|: s10 >= 0, s10 <= z' + z'' + @y + @ys + 2, s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 21 + 5*z'' + 5*z1 + 5*z2 }-> 1 + z' + s9 :|: s9 >= 0, s9 <= z'' + (1 + z1 + z2), z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 21 + 5*z' + 5*z'' + 5*z2 }-> 1 + z1 + s8 :|: s8 >= 0, s8 <= 1 + z' + z'' + z2, z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 12 + 4*@x2 + 4*@xs' + 4*z' }-> mergesort#3(s11) :|: s11 >= 0, s11 <= 1 + z' + (1 + @x2 + @xs') + 1, z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 3 + 4*z }-> s12 :|: s12 >= 0, s12 <= z + 1, z >= 0 msplit#1(z) -{ 2 + 4*@xs }-> s13 :|: s13 >= 0, s13 <= @xs + @x1 + 2, @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 5 + 4*@xs' }-> s15 :|: s14 >= 0, s14 <= @xs' + 1, s15 >= 0, s15 <= s14 + z' + @x2 + 2, z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] #less: runtime: O(1) [1], size: O(1) [2] merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z''] merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2] msplit#1: runtime: O(n^1) [2 + 4*z], size: O(n^1) [1 + z] msplit#2: runtime: O(n^1) [1 + 4*z], size: O(n^1) [2 + z + z'] mergesort#3: runtime: ?, size: O(n^2) [12 + 9*z + z^2] mergesort#1: runtime: ?, size: O(n^2) [35 + 27*z + 4*z^2] mergesort#2: runtime: ?, size: O(n^2) [35 + 13*z + 2*z*z' + z^2 + 14*z' + z'^2] ---------------------------------------- (63) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: mergesort#3 after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (64) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: z >= 0 #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3 #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3 #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2 #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2 #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0 #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0 #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0 merge(z, z') -{ 15 + 5*z + 5*z' }-> s6 :|: s6 >= 0, s6 <= z + z', z >= 0, z' >= 0 merge#1(z, z') -{ 19 + 5*@x + 5*@xs + 5*z' }-> s7 :|: s7 >= 0, s7 <= z' + @x + @xs + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0 merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0 merge#2(z, z', z'') -{ 23 + 5*@y + 5*@ys + 5*z' + 5*z'' }-> s10 :|: s10 >= 0, s10 <= z' + z'' + @y + @ys + 2, s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0 merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0 merge#3(z, z', z'', z1, z2) -{ 21 + 5*z'' + 5*z1 + 5*z2 }-> 1 + z' + s9 :|: s9 >= 0, s9 <= z'' + (1 + z1 + z2), z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0 merge#3(z, z', z'', z1, z2) -{ 21 + 5*z' + 5*z'' + 5*z2 }-> 1 + z1 + s8 :|: s8 >= 0, s8 <= 1 + z' + z'' + z2, z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0 mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#2(z, z') -{ 12 + 4*@x2 + 4*@xs' + 4*z' }-> mergesort#3(s11) :|: s11 >= 0, s11 <= 1 + z' + (1 + @x2 + @xs') + 1, z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0 mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: z >= 0 msplit(z) -{ 3 + 4*z }-> s12 :|: s12 >= 0, s12 <= z + 1, z >= 0 msplit#1(z) -{ 2 + 4*@xs }-> s13 :|: s13 >= 0, s13 <= @xs + @x1 + 2, @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 5 + 4*@xs' }-> s15 :|: s14 >= 0, s14 <= @xs' + 1, s15 >= 0, s15 <= s14 + z' + @x2 + 2, z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0 msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0 Function symbols to be analyzed: {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort} Previous analysis results are: #compare: runtime: O(1) [0], size: O(1) [3] msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z''] #cklt: runtime: O(1) [0], size: O(1) [2] #less: runtime: O(1) [1], size: O(1) [2] merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z''] merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z'] merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2] msplit#1: runtime: O(n^1) [2 + 4*z], size: O(n^1) [1 + z] msplit#2: runtime: O(n^1) [1 + 4*z], size: O(n^1) [2 + z + z'] mergesort#3: runtime: INF, size: O(n^2) [12 + 9*z + z^2] mergesort#1: runtime: ?, size: O(n^2) [35 + 27*z + 4*z^2] mergesort#2: runtime: ?, size: O(n^2) [35 + 13*z + 2*z*z' + z^2 + 14*z' + z'^2] ---------------------------------------- (65) 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: #cklt(v0) -> null_#cklt [0] #compare(v0, v1) -> null_#compare [0] merge#3(v0, v1, v2, v3, v4) -> null_merge#3 [0] mergesort#3(v0) -> null_mergesort#3 [0] msplit#3(v0, v1, v2) -> null_msplit#3 [0] merge#1(v0, v1) -> null_merge#1 [0] merge#2(v0, v1, v2) -> null_merge#2 [0] mergesort#1(v0) -> null_mergesort#1 [0] mergesort#2(v0, v1) -> null_mergesort#2 [0] msplit#1(v0) -> null_msplit#1 [0] msplit#2(v0, v1) -> null_msplit#2 [0] And the following fresh constants: null_#cklt, null_#compare, null_merge#3, null_mergesort#3, null_msplit#3, null_merge#1, null_merge#2, null_mergesort#1, null_mergesort#2, null_msplit#1, null_msplit#2 ---------------------------------------- (66) 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: #less(@x, @y) -> #cklt(#compare(@x, @y)) [1] merge(@l1, @l2) -> merge#1(@l1, @l2) [1] merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) [1] merge#1(nil, @l2) -> @l2 [1] merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys) [1] merge#2(nil, @x, @xs) -> ::(@x, @xs) [1] merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) [1] merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) [1] mergesort(@l) -> mergesort#1(@l) [1] mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) [1] mergesort#1(nil) -> nil [1] mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs')))) [1] mergesort#2(nil, @x1) -> ::(@x1, nil) [1] mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2)) [1] msplit(@l) -> msplit#1(@l) [1] msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) [1] msplit#1(nil) -> tuple#2(nil, nil) [1] msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2) [1] msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) [1] msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) [1] #cklt(#EQ) -> #false [0] #cklt(#GT) -> #false [0] #cklt(#LT) -> #true [0] #compare(#0, #0) -> #EQ [0] #compare(#0, #neg(@y)) -> #GT [0] #compare(#0, #pos(@y)) -> #LT [0] #compare(#0, #s(@y)) -> #LT [0] #compare(#neg(@x), #0) -> #LT [0] #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0] #compare(#neg(@x), #pos(@y)) -> #LT [0] #compare(#pos(@x), #0) -> #GT [0] #compare(#pos(@x), #neg(@y)) -> #GT [0] #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0] #compare(#s(@x), #0) -> #GT [0] #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0] #cklt(v0) -> null_#cklt [0] #compare(v0, v1) -> null_#compare [0] merge#3(v0, v1, v2, v3, v4) -> null_merge#3 [0] mergesort#3(v0) -> null_mergesort#3 [0] msplit#3(v0, v1, v2) -> null_msplit#3 [0] merge#1(v0, v1) -> null_merge#1 [0] merge#2(v0, v1, v2) -> null_merge#2 [0] mergesort#1(v0) -> null_mergesort#1 [0] mergesort#2(v0, v1) -> null_mergesort#2 [0] msplit#1(v0) -> null_msplit#1 [0] msplit#2(v0, v1) -> null_msplit#2 [0] The TRS has the following type information: #less :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true:null_#cklt #cklt :: #EQ:#GT:#LT:null_#compare -> #false:#true:null_#cklt #compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT:null_#compare merge :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 merge#1 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 :: :: #0:#neg:#pos:#s -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 merge#2 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> #0:#neg:#pos:#s -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 nil :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 merge#3 :: #false:#true:null_#cklt -> #0:#neg:#pos:#s -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> #0:#neg:#pos:#s -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 #false :: #false:#true:null_#cklt #true :: #false:#true:null_#cklt mergesort :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 mergesort#1 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 mergesort#2 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> #0:#neg:#pos:#s -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 mergesort#3 :: tuple#2:null_msplit#3:null_msplit#1:null_msplit#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 msplit :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> tuple#2:null_msplit#3:null_msplit#1:null_msplit#2 tuple#2 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> tuple#2:null_msplit#3:null_msplit#1:null_msplit#2 msplit#1 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> tuple#2:null_msplit#3:null_msplit#1:null_msplit#2 msplit#2 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> #0:#neg:#pos:#s -> tuple#2:null_msplit#3:null_msplit#1:null_msplit#2 msplit#3 :: tuple#2:null_msplit#3:null_msplit#1:null_msplit#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2:null_msplit#3:null_msplit#1:null_msplit#2 #EQ :: #EQ:#GT:#LT:null_#compare #GT :: #EQ:#GT:#LT:null_#compare #LT :: #EQ:#GT:#LT:null_#compare #0 :: #0:#neg:#pos:#s #neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s #pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s #s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s null_#cklt :: #false:#true:null_#cklt null_#compare :: #EQ:#GT:#LT:null_#compare null_merge#3 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 null_mergesort#3 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 null_msplit#3 :: tuple#2:null_msplit#3:null_msplit#1:null_msplit#2 null_merge#1 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 null_merge#2 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 null_mergesort#1 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 null_mergesort#2 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 null_msplit#1 :: tuple#2:null_msplit#3:null_msplit#1:null_msplit#2 null_msplit#2 :: tuple#2:null_msplit#3:null_msplit#1:null_msplit#2 Rewrite Strategy: INNERMOST ---------------------------------------- (67) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID)) Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction. The constant constructors are abstracted as follows: nil => 0 #false => 1 #true => 2 #EQ => 1 #GT => 2 #LT => 3 #0 => 0 null_#cklt => 0 null_#compare => 0 null_merge#3 => 0 null_mergesort#3 => 0 null_msplit#3 => 0 null_merge#1 => 0 null_merge#2 => 0 null_mergesort#1 => 0 null_mergesort#2 => 0 null_msplit#1 => 0 null_msplit#2 => 0 ---------------------------------------- (68) Obligation: Complexity RNTS consisting of the following rules: #cklt(z) -{ 0 }-> 2 :|: z = 3 #cklt(z) -{ 0 }-> 1 :|: z = 1 #cklt(z) -{ 0 }-> 1 :|: z = 2 #cklt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 0 #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 0 #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0 #compare(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 #compare(z, z') -{ 0 }-> #compare(@x, @y) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0 #compare(z, z') -{ 0 }-> #compare(@y, @x) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0 #less(z, z') -{ 1 }-> #cklt(#compare(@x, @y)) :|: z = @x, @x >= 0, z' = @y, @y >= 0 merge(z, z') -{ 1 }-> merge#1(@l1, @l2) :|: @l1 >= 0, z' = @l2, @l2 >= 0, z = @l1 merge#1(z, z') -{ 1 }-> @l2 :|: z' = @l2, @l2 >= 0, z = 0 merge#1(z, z') -{ 1 }-> merge#2(@l2, @x, @xs) :|: z' = @l2, @x >= 0, z = 1 + @x + @xs, @l2 >= 0, @xs >= 0 merge#1(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 merge#2(z, z', z'') -{ 1 }-> merge#3(#less(@x, @y), @x, @xs, @y, @ys) :|: z = 1 + @y + @ys, @x >= 0, @xs >= 0, @y >= 0, z' = @x, z'' = @xs, @ys >= 0 merge#2(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 merge#2(z, z', z'') -{ 1 }-> 1 + @x + @xs :|: @x >= 0, @xs >= 0, z = 0, z' = @x, z'' = @xs merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, v4 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z2 = v4, v2 >= 0, v3 >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + @x + merge(@xs, 1 + @y + @ys) :|: z = 2, @x >= 0, z1 = @y, @xs >= 0, z2 = @ys, @y >= 0, z' = @x, z'' = @xs, @ys >= 0 merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + @y + merge(1 + @x + @xs, @ys) :|: @x >= 0, z = 1, z1 = @y, @xs >= 0, z2 = @ys, @y >= 0, z' = @x, z'' = @xs, @ys >= 0 mergesort(z) -{ 1 }-> mergesort#1(@l) :|: z = @l, @l >= 0 mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 mergesort#1(z) -{ 1 }-> 0 :|: z = 0 mergesort#1(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 mergesort#2(z, z') -{ 1 }-> mergesort#3(msplit(1 + @x1 + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', z' = @x1, @xs' >= 0, @x1 >= 0, @x2 >= 0 mergesort#2(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 mergesort#2(z, z') -{ 1 }-> 1 + @x1 + 0 :|: z' = @x1, @x1 >= 0, z = 0 mergesort#3(z) -{ 1 }-> merge(mergesort(@l1), mergesort(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0 mergesort#3(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 msplit(z) -{ 1 }-> msplit#1(@l) :|: z = @l, @l >= 0 msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0 msplit#1(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0 msplit#2(z, z') -{ 1 }-> msplit#3(msplit(@xs'), @x1, @x2) :|: z = 1 + @x2 + @xs', z' = @x1, @xs' >= 0, @x1 >= 0, @x2 >= 0 msplit#2(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 msplit#2(z, z') -{ 1 }-> 1 + (1 + @x1 + 0) + 0 :|: z' = @x1, @x1 >= 0, z = 0 msplit#3(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + @x1 + @l1) + (1 + @x2 + @l2) :|: z' = @x1, @l1 >= 0, z = 1 + @l1 + @l2, z'' = @x2, @x1 >= 0, @l2 >= 0, @x2 >= 0 Only complete derivations are relevant for the runtime complexity. ---------------------------------------- (69) CpxTrsToCdtProof (UPPER BOUND(ID)) Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT ---------------------------------------- (70) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #CKLT(#EQ) -> c #CKLT(#GT) -> c1 #CKLT(#LT) -> c2 #COMPARE(#0, #0) -> c3 #COMPARE(#0, #neg(z0)) -> c4 #COMPARE(#0, #pos(z0)) -> c5 #COMPARE(#0, #s(z0)) -> c6 #COMPARE(#neg(z0), #0) -> c7 #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#neg(z0), #pos(z1)) -> c9 #COMPARE(#pos(z0), #0) -> c10 #COMPARE(#pos(z0), #neg(z1)) -> c11 #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #0) -> c13 #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) #LESS(z0, z1) -> c15(#CKLT(#compare(z0, z1)), #COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#1(nil, z0) -> c18 MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#2(nil, z0, z1) -> c20 MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#1(nil) -> c25 MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#2(nil, z0) -> c27 MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#1(nil) -> c32 MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT#3(msplit(z1), z2, z0), MSPLIT(z1)) MSPLIT#2(nil, z0) -> c34 MSPLIT#3(tuple#2(z0, z1), z2, z3) -> c35 S tuples: #LESS(z0, z1) -> c15(#CKLT(#compare(z0, z1)), #COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#1(nil, z0) -> c18 MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#2(nil, z0, z1) -> c20 MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#1(nil) -> c25 MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#2(nil, z0) -> c27 MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#1(nil) -> c32 MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT#3(msplit(z1), z2, z0), MSPLIT(z1)) MSPLIT#2(nil, z0) -> c34 MSPLIT#3(tuple#2(z0, z1), z2, z3) -> c35 K tuples:none Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #CKLT_1, #COMPARE_2, #LESS_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, MSPLIT#2_2, MSPLIT#3_3 Compound Symbols: c, c1, c2, c3, c4, c5, c6, c7, c8_1, c9, c10, c11, c12_1, c13, c14_1, c15_2, c16_1, c17_1, c18, c19_2, c20, c21_1, c22_1, c23_1, c24_1, c25, c26_2, c27, c28_2, c29_2, c30_1, c31_1, c32, c33_2, c34, c35 ---------------------------------------- (71) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 19 trailing nodes: #COMPARE(#s(z0), #0) -> c13 MERGESORT#1(nil) -> c25 #COMPARE(#pos(z0), #0) -> c10 #CKLT(#GT) -> c1 #CKLT(#LT) -> c2 #COMPARE(#0, #s(z0)) -> c6 MERGE#2(nil, z0, z1) -> c20 #CKLT(#EQ) -> c MSPLIT#2(nil, z0) -> c34 #COMPARE(#0, #pos(z0)) -> c5 MERGE#1(nil, z0) -> c18 MSPLIT#1(nil) -> c32 MSPLIT#3(tuple#2(z0, z1), z2, z3) -> c35 #COMPARE(#0, #0) -> c3 MERGESORT#2(nil, z0) -> c27 #COMPARE(#0, #neg(z0)) -> c4 #COMPARE(#neg(z0), #pos(z1)) -> c9 #COMPARE(#neg(z0), #0) -> c7 #COMPARE(#pos(z0), #neg(z1)) -> c11 ---------------------------------------- (72) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) #LESS(z0, z1) -> c15(#CKLT(#compare(z0, z1)), #COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT#3(msplit(z1), z2, z0), MSPLIT(z1)) S tuples: #LESS(z0, z1) -> c15(#CKLT(#compare(z0, z1)), #COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT#3(msplit(z1), z2, z0), MSPLIT(z1)) K tuples:none Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, #LESS_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, MSPLIT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c15_2, c16_1, c17_1, c19_2, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c33_2 ---------------------------------------- (73) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (74) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) K tuples:none Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c19_2, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1 ---------------------------------------- (75) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) We considered the (Usable) Rules: merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) mergesort#1(nil) -> nil mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) #compare(#0, #neg(z0)) -> #GT msplit#1(nil) -> tuple#2(nil, nil) #compare(#pos(z0), #0) -> #GT #cklt(#GT) -> #false msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#neg(z0), #0) -> #LT merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) #compare(#pos(z0), #neg(z1)) -> #GT merge(z0, z1) -> merge#1(z0, z1) mergesort#2(nil, z0) -> ::(z0, nil) merge#1(nil, z0) -> z0 #compare(#0, #pos(z0)) -> #LT mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #compare(#0, #0) -> #EQ #compare(#s(z0), #0) -> #GT msplit(z0) -> msplit#1(z0) #cklt(#EQ) -> #false #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) mergesort(z0) -> mergesort#1(z0) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) #cklt(#LT) -> #true msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) And the Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) The order we found is given by the following interpretation: Polynomial interpretation : POL(#0) = [2] POL(#COMPARE(x_1, x_2)) = 0 POL(#EQ) = 0 POL(#GT) = 0 POL(#LESS(x_1, x_2)) = 0 POL(#LT) = [1] POL(#cklt(x_1)) = [2]x_1 POL(#compare(x_1, x_2)) = x_1*x_2 POL(#false) = 0 POL(#less(x_1, x_2)) = [2]x_1*x_2 POL(#neg(x_1)) = [2] + x_1 POL(#pos(x_1)) = [2] + x_1 POL(#s(x_1)) = [1] + x_1 POL(#true) = [2] POL(::(x_1, x_2)) = x_1 + x_2 POL(MERGE(x_1, x_2)) = [2]x_1*x_2 POL(MERGE#1(x_1, x_2)) = [2]x_1*x_2 POL(MERGE#2(x_1, x_2, x_3)) = [2]x_1*x_3 + [2]x_1*x_2 POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = x_1 + [2]x_3*x_5 + [2]x_2*x_5 + [2]x_3*x_4 POL(MERGESORT(x_1)) = x_1^2 POL(MERGESORT#1(x_1)) = x_1^2 POL(MERGESORT#2(x_1, x_2)) = x_2^2 + [2]x_1*x_2 + x_1^2 POL(MERGESORT#3(x_1)) = x_1^2 POL(MSPLIT(x_1)) = 0 POL(MSPLIT#1(x_1)) = 0 POL(MSPLIT#2(x_1, x_2)) = 0 POL(c12(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(c19(x_1, x_2)) = x_1 + x_2 POL(c21(x_1)) = x_1 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c24(x_1)) = x_1 POL(c26(x_1, x_2)) = x_1 + x_2 POL(c28(x_1, x_2)) = x_1 + x_2 POL(c29(x_1, x_2)) = x_1 + x_2 POL(c30(x_1)) = x_1 POL(c31(x_1)) = x_1 POL(c33(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(merge(x_1, x_2)) = x_1 + x_2 POL(merge#1(x_1, x_2)) = x_1 + x_2 POL(merge#2(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = x_2 + x_3 + x_4 + x_5 POL(mergesort(x_1)) = x_1 POL(mergesort#1(x_1)) = x_1 POL(mergesort#2(x_1, x_2)) = x_1 + x_2 POL(mergesort#3(x_1)) = x_1 POL(msplit(x_1)) = x_1 POL(msplit#1(x_1)) = x_1 POL(msplit#2(x_1, x_2)) = x_1 + x_2 POL(msplit#3(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(nil) = 0 POL(tuple#2(x_1, x_2)) = x_1 + x_2 ---------------------------------------- (76) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c19_2, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1 ---------------------------------------- (77) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) We considered the (Usable) Rules: merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) mergesort#1(nil) -> nil mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) #compare(#0, #neg(z0)) -> #GT msplit#1(nil) -> tuple#2(nil, nil) #compare(#pos(z0), #0) -> #GT #cklt(#GT) -> #false msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#neg(z0), #0) -> #LT merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) #compare(#pos(z0), #neg(z1)) -> #GT merge(z0, z1) -> merge#1(z0, z1) mergesort#2(nil, z0) -> ::(z0, nil) merge#1(nil, z0) -> z0 #compare(#0, #pos(z0)) -> #LT mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #compare(#0, #0) -> #EQ #compare(#s(z0), #0) -> #GT msplit(z0) -> msplit#1(z0) #cklt(#EQ) -> #false #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) mergesort(z0) -> mergesort#1(z0) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) #cklt(#LT) -> #true msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) And the Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) The order we found is given by the following interpretation: Polynomial interpretation : POL(#0) = [1] POL(#COMPARE(x_1, x_2)) = 0 POL(#EQ) = [1] POL(#GT) = [1] POL(#LESS(x_1, x_2)) = 0 POL(#LT) = 0 POL(#cklt(x_1)) = x_1 POL(#compare(x_1, x_2)) = x_1*x_2 POL(#false) = [1] POL(#less(x_1, x_2)) = x_1*x_2 POL(#neg(x_1)) = [1] + x_1 POL(#pos(x_1)) = [1] + x_1 POL(#s(x_1)) = [1] + x_1 POL(#true) = 0 POL(::(x_1, x_2)) = x_1 + x_2 POL(MERGE(x_1, x_2)) = x_1*x_2 POL(MERGE#1(x_1, x_2)) = x_1*x_2 POL(MERGE#2(x_1, x_2, x_3)) = x_1*x_3 + x_1*x_2 POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = x_1 + x_3*x_5 + x_2*x_5 + x_3*x_4 POL(MERGESORT(x_1)) = x_1^2 POL(MERGESORT#1(x_1)) = x_1^2 POL(MERGESORT#2(x_1, x_2)) = x_2^2 + [2]x_1*x_2 + x_1^2 POL(MERGESORT#3(x_1)) = x_1^2 POL(MSPLIT(x_1)) = 0 POL(MSPLIT#1(x_1)) = 0 POL(MSPLIT#2(x_1, x_2)) = 0 POL(c12(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(c19(x_1, x_2)) = x_1 + x_2 POL(c21(x_1)) = x_1 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c24(x_1)) = x_1 POL(c26(x_1, x_2)) = x_1 + x_2 POL(c28(x_1, x_2)) = x_1 + x_2 POL(c29(x_1, x_2)) = x_1 + x_2 POL(c30(x_1)) = x_1 POL(c31(x_1)) = x_1 POL(c33(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(merge(x_1, x_2)) = x_1 + x_2 POL(merge#1(x_1, x_2)) = x_1 + x_2 POL(merge#2(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = x_2 + x_3 + x_4 + x_5 POL(mergesort(x_1)) = x_1 POL(mergesort#1(x_1)) = x_1 POL(mergesort#2(x_1, x_2)) = x_1 + x_2 POL(mergesort#3(x_1)) = x_1 POL(msplit(x_1)) = x_1 POL(msplit#1(x_1)) = x_1 POL(msplit#2(x_1, x_2)) = x_1 + x_2 POL(msplit#3(x_1, x_2, x_3)) = x_1 + x_2 + x_3 POL(nil) = 0 POL(tuple#2(x_1, x_2)) = x_1 + x_2 ---------------------------------------- (78) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c19_2, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1 ---------------------------------------- (79) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) We considered the (Usable) Rules: merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(nil, z0) -> ::(z0, nil) merge#1(nil, z0) -> z0 mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) msplit(z0) -> msplit#1(z0) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) merge#2(nil, z0, z1) -> ::(z0, z1) mergesort(z0) -> mergesort#1(z0) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) And the Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) The order we found is given by the following interpretation: Polynomial interpretation : POL(#0) = [2] POL(#COMPARE(x_1, x_2)) = 0 POL(#EQ) = [2] POL(#GT) = [1] POL(#LESS(x_1, x_2)) = 0 POL(#LT) = [1] POL(#cklt(x_1)) = [1] POL(#compare(x_1, x_2)) = 0 POL(#false) = 0 POL(#less(x_1, x_2)) = 0 POL(#neg(x_1)) = 0 POL(#pos(x_1)) = 0 POL(#s(x_1)) = 0 POL(#true) = 0 POL(::(x_1, x_2)) = [1] + x_2 POL(MERGE(x_1, x_2)) = x_1*x_2 POL(MERGE#1(x_1, x_2)) = x_1*x_2 POL(MERGE#2(x_1, x_2, x_3)) = x_1 + x_1*x_3 POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = x_3 + x_5 + x_3*x_5 POL(MERGESORT(x_1)) = [1] + x_1^2 POL(MERGESORT#1(x_1)) = [1] + x_1^2 POL(MERGESORT#2(x_1, x_2)) = [2] + [2]x_1 + x_1^2 POL(MERGESORT#3(x_1)) = [1] + x_1^2 POL(MSPLIT(x_1)) = 0 POL(MSPLIT#1(x_1)) = 0 POL(MSPLIT#2(x_1, x_2)) = 0 POL(c12(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(c19(x_1, x_2)) = x_1 + x_2 POL(c21(x_1)) = x_1 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c24(x_1)) = x_1 POL(c26(x_1, x_2)) = x_1 + x_2 POL(c28(x_1, x_2)) = x_1 + x_2 POL(c29(x_1, x_2)) = x_1 + x_2 POL(c30(x_1)) = x_1 POL(c31(x_1)) = x_1 POL(c33(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(merge(x_1, x_2)) = x_1 + x_2 POL(merge#1(x_1, x_2)) = x_1 + x_2 POL(merge#2(x_1, x_2, x_3)) = [1] + x_1 + x_3 POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [2] + x_3 + x_5 POL(mergesort(x_1)) = x_1 POL(mergesort#1(x_1)) = x_1 POL(mergesort#2(x_1, x_2)) = [1] + x_1 POL(mergesort#3(x_1)) = x_1 POL(msplit(x_1)) = x_1 POL(msplit#1(x_1)) = x_1 POL(msplit#2(x_1, x_2)) = [1] + x_1 POL(msplit#3(x_1, x_2, x_3)) = [2] + x_1 POL(nil) = 0 POL(tuple#2(x_1, x_2)) = x_1 + x_2 ---------------------------------------- (80) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c19_2, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1 ---------------------------------------- (81) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) ---------------------------------------- (82) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c19_2, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1 ---------------------------------------- (83) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) by MERGE#2(::(z1, x1), z0, x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), z0, x3, z1, x1), #LESS(z0, z1)) ---------------------------------------- (84) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(z1, x1), z0, x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), z0, x3, z1, x1), #LESS(z0, z1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1, c19_2 ---------------------------------------- (85) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) by MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1)))) ---------------------------------------- (86) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(z1, x1), z0, x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), z0, x3, z1, x1), #LESS(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1)))) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1)))) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1, c19_2, c26_2 ---------------------------------------- (87) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) by MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) ---------------------------------------- (88) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(z1, x1), z0, x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), z0, x3, z1, x1), #LESS(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c29_2, c30_1, c31_1, c15_1, c33_1, c19_2, c26_2, c28_2 ---------------------------------------- (89) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) by MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) ---------------------------------------- (90) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(z1, x1), z0, x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), z0, x3, z1, x1), #LESS(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c26_2, c28_2, c29_2 ---------------------------------------- (91) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace MERGE#2(::(z1, x1), z0, x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), z0, x3, z1, x1), #LESS(z0, z1)) by MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) ---------------------------------------- (92) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#2_2, MERGESORT#3_1, MERGE#2_3 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c26_2, c28_2, c29_2, c19_2, c19_1 ---------------------------------------- (93) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1)))) by MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) ---------------------------------------- (94) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c28_2, c29_2, c19_2, c19_1, c26_2, c26_1 ---------------------------------------- (95) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) We considered the (Usable) Rules:none And the Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(#0) = 0 POL(#COMPARE(x_1, x_2)) = 0 POL(#EQ) = [1] POL(#GT) = [1] POL(#LESS(x_1, x_2)) = 0 POL(#LT) = [1] POL(#cklt(x_1)) = [1] POL(#compare(x_1, x_2)) = x_1 + x_2 POL(#false) = [1] POL(#less(x_1, x_2)) = [1] + x_1 + x_2 POL(#neg(x_1)) = 0 POL(#pos(x_1)) = 0 POL(#s(x_1)) = 0 POL(#true) = [1] POL(::(x_1, x_2)) = 0 POL(MERGE(x_1, x_2)) = 0 POL(MERGE#1(x_1, x_2)) = 0 POL(MERGE#2(x_1, x_2, x_3)) = 0 POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0 POL(MERGESORT(x_1)) = [1] POL(MERGESORT#1(x_1)) = [1] POL(MERGESORT#2(x_1, x_2)) = [1] POL(MERGESORT#3(x_1)) = [1] POL(MSPLIT(x_1)) = 0 POL(MSPLIT#1(x_1)) = 0 POL(MSPLIT#2(x_1, x_2)) = 0 POL(c12(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(c19(x_1)) = x_1 POL(c19(x_1, x_2)) = x_1 + x_2 POL(c21(x_1)) = x_1 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c24(x_1)) = x_1 POL(c26(x_1)) = x_1 POL(c26(x_1, x_2)) = x_1 + x_2 POL(c28(x_1, x_2)) = x_1 + x_2 POL(c29(x_1, x_2)) = x_1 + x_2 POL(c30(x_1)) = x_1 POL(c31(x_1)) = x_1 POL(c33(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(merge(x_1, x_2)) = [1] + x_1 + x_2 POL(merge#1(x_1, x_2)) = [1] + x_1 + x_2 POL(merge#2(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3 POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_3 + x_4 + x_5 POL(mergesort(x_1)) = [1] + x_1 POL(mergesort#1(x_1)) = [1] + x_1 POL(mergesort#2(x_1, x_2)) = [1] + x_1 + x_2 POL(mergesort#3(x_1)) = [1] POL(msplit(x_1)) = [1] + x_1 POL(msplit#1(x_1)) = [1] + x_1 POL(msplit#2(x_1, x_2)) = [1] + x_1 + x_2 POL(msplit#3(x_1, x_2, x_3)) = [1] + x_2 + x_3 POL(nil) = 0 POL(tuple#2(x_1, x_2)) = 0 ---------------------------------------- (96) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c28_2, c29_2, c19_2, c19_1, c26_2, c26_1 ---------------------------------------- (97) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) by MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) ---------------------------------------- (98) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c28_2, c29_2, c19_2, c19_1, c26_2, c26_1 ---------------------------------------- (99) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) We considered the (Usable) Rules: msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) And the Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) The order we found is given by the following interpretation: Polynomial interpretation : POL(#0) = 0 POL(#COMPARE(x_1, x_2)) = 0 POL(#EQ) = 0 POL(#GT) = 0 POL(#LESS(x_1, x_2)) = 0 POL(#LT) = 0 POL(#cklt(x_1)) = 0 POL(#compare(x_1, x_2)) = 0 POL(#false) = 0 POL(#less(x_1, x_2)) = [3] + [3]x_1 + [3]x_2 POL(#neg(x_1)) = 0 POL(#pos(x_1)) = 0 POL(#s(x_1)) = 0 POL(#true) = 0 POL(::(x_1, x_2)) = 0 POL(MERGE(x_1, x_2)) = 0 POL(MERGE#1(x_1, x_2)) = 0 POL(MERGE#2(x_1, x_2, x_3)) = 0 POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0 POL(MERGESORT(x_1)) = 0 POL(MERGESORT#1(x_1)) = 0 POL(MERGESORT#2(x_1, x_2)) = 0 POL(MERGESORT#3(x_1)) = x_1 POL(MSPLIT(x_1)) = 0 POL(MSPLIT#1(x_1)) = 0 POL(MSPLIT#2(x_1, x_2)) = 0 POL(c12(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(c19(x_1)) = x_1 POL(c19(x_1, x_2)) = x_1 + x_2 POL(c21(x_1)) = x_1 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c24(x_1)) = x_1 POL(c26(x_1)) = x_1 POL(c26(x_1, x_2)) = x_1 + x_2 POL(c28(x_1, x_2)) = x_1 + x_2 POL(c29(x_1, x_2)) = x_1 + x_2 POL(c30(x_1)) = x_1 POL(c31(x_1)) = x_1 POL(c33(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(merge(x_1, x_2)) = [3] POL(merge#1(x_1, x_2)) = [3] + [3]x_1 + [3]x_2 POL(merge#2(x_1, x_2, x_3)) = [3] + [3]x_1 + [3]x_2 + [3]x_3 POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [3] + [3]x_2 + [3]x_3 + [3]x_4 + [3]x_5 POL(mergesort(x_1)) = [3]x_1 POL(mergesort#1(x_1)) = [3]x_1 POL(mergesort#2(x_1, x_2)) = [3] + [3]x_1 + [3]x_2 POL(mergesort#3(x_1)) = [3] POL(msplit(x_1)) = 0 POL(msplit#1(x_1)) = [3] + [3]x_1 POL(msplit#2(x_1, x_2)) = 0 POL(msplit#3(x_1, x_2, x_3)) = 0 POL(nil) = [1] POL(tuple#2(x_1, x_2)) = x_2 ---------------------------------------- (100) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c28_2, c29_2, c19_2, c19_1, c26_2, c26_1 ---------------------------------------- (101) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) We considered the (Usable) Rules: msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#1(nil) -> tuple#2(nil, nil) msplit(z0) -> msplit#1(z0) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) And the Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) The order we found is given by the following interpretation: Polynomial interpretation : POL(#0) = 0 POL(#COMPARE(x_1, x_2)) = 0 POL(#EQ) = 0 POL(#GT) = 0 POL(#LESS(x_1, x_2)) = 0 POL(#LT) = 0 POL(#cklt(x_1)) = 0 POL(#compare(x_1, x_2)) = 0 POL(#false) = 0 POL(#less(x_1, x_2)) = [3] + [3]x_1 + [3]x_2 POL(#neg(x_1)) = 0 POL(#pos(x_1)) = 0 POL(#s(x_1)) = 0 POL(#true) = 0 POL(::(x_1, x_2)) = [1] + x_2 POL(MERGE(x_1, x_2)) = 0 POL(MERGE#1(x_1, x_2)) = 0 POL(MERGE#2(x_1, x_2, x_3)) = 0 POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0 POL(MERGESORT(x_1)) = [2]x_1 POL(MERGESORT#1(x_1)) = [2]x_1 POL(MERGESORT#2(x_1, x_2)) = [2] + [2]x_1 POL(MERGESORT#3(x_1)) = [2]x_1 POL(MSPLIT(x_1)) = 0 POL(MSPLIT#1(x_1)) = 0 POL(MSPLIT#2(x_1, x_2)) = 0 POL(c12(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(c19(x_1)) = x_1 POL(c19(x_1, x_2)) = x_1 + x_2 POL(c21(x_1)) = x_1 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c24(x_1)) = x_1 POL(c26(x_1)) = x_1 POL(c26(x_1, x_2)) = x_1 + x_2 POL(c28(x_1, x_2)) = x_1 + x_2 POL(c29(x_1, x_2)) = x_1 + x_2 POL(c30(x_1)) = x_1 POL(c31(x_1)) = x_1 POL(c33(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(merge(x_1, x_2)) = [3] POL(merge#1(x_1, x_2)) = [3] + [3]x_1 + [3]x_2 POL(merge#2(x_1, x_2, x_3)) = [3] + [3]x_1 + [3]x_2 + [3]x_3 POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [3] + [3]x_2 + [3]x_3 + [3]x_4 + [3]x_5 POL(mergesort(x_1)) = [3]x_1 POL(mergesort#1(x_1)) = [3]x_1 POL(mergesort#2(x_1, x_2)) = [3] + [3]x_1 + [3]x_2 POL(mergesort#3(x_1)) = [3] POL(msplit(x_1)) = x_1 POL(msplit#1(x_1)) = x_1 POL(msplit#2(x_1, x_2)) = [1] + x_1 POL(msplit#3(x_1, x_2, x_3)) = [2] + x_1 POL(nil) = 0 POL(tuple#2(x_1, x_2)) = x_1 + x_2 ---------------------------------------- (102) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c28_2, c29_2, c19_2, c19_1, c26_2, c26_1 ---------------------------------------- (103) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) by MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort#1(x0), mergesort#1(z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) ---------------------------------------- (104) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c29_2, c19_2, c19_1, c26_2, c26_1, c28_2 ---------------------------------------- (105) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) We considered the (Usable) Rules: msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) And the Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) The order we found is given by the following interpretation: Polynomial interpretation : POL(#0) = 0 POL(#COMPARE(x_1, x_2)) = 0 POL(#EQ) = [1] POL(#GT) = [1] POL(#LESS(x_1, x_2)) = 0 POL(#LT) = [1] POL(#cklt(x_1)) = [1] POL(#compare(x_1, x_2)) = 0 POL(#false) = [1] POL(#less(x_1, x_2)) = [1] + x_1 + x_2 POL(#neg(x_1)) = 0 POL(#pos(x_1)) = 0 POL(#s(x_1)) = 0 POL(#true) = [1] POL(::(x_1, x_2)) = 0 POL(MERGE(x_1, x_2)) = 0 POL(MERGE#1(x_1, x_2)) = 0 POL(MERGE#2(x_1, x_2, x_3)) = 0 POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0 POL(MERGESORT(x_1)) = 0 POL(MERGESORT#1(x_1)) = 0 POL(MERGESORT#2(x_1, x_2)) = 0 POL(MERGESORT#3(x_1)) = x_1 POL(MSPLIT(x_1)) = 0 POL(MSPLIT#1(x_1)) = 0 POL(MSPLIT#2(x_1, x_2)) = 0 POL(c12(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(c19(x_1)) = x_1 POL(c19(x_1, x_2)) = x_1 + x_2 POL(c21(x_1)) = x_1 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c24(x_1)) = x_1 POL(c26(x_1)) = x_1 POL(c26(x_1, x_2)) = x_1 + x_2 POL(c28(x_1, x_2)) = x_1 + x_2 POL(c29(x_1, x_2)) = x_1 + x_2 POL(c30(x_1)) = x_1 POL(c31(x_1)) = x_1 POL(c33(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(merge(x_1, x_2)) = [1] + x_1 + x_2 POL(merge#1(x_1, x_2)) = [1] + x_1 + x_2 POL(merge#2(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3 POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_3 + x_4 + x_5 POL(mergesort(x_1)) = [1] + x_1 POL(mergesort#1(x_1)) = [1] + x_1 POL(mergesort#2(x_1, x_2)) = [1] + x_1 + x_2 POL(mergesort#3(x_1)) = [1] POL(msplit(x_1)) = [1] + x_1 POL(msplit#1(x_1)) = [1] + x_1 POL(msplit#2(x_1, x_2)) = 0 POL(msplit#3(x_1, x_2, x_3)) = 0 POL(nil) = [1] POL(tuple#2(x_1, x_2)) = x_1 ---------------------------------------- (106) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c29_2, c19_2, c19_1, c26_2, c26_1, c28_2 ---------------------------------------- (107) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) by MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) ---------------------------------------- (108) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c29_2, c19_2, c19_1, c26_2, c26_1, c28_2 ---------------------------------------- (109) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) We considered the (Usable) Rules: msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) And the Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) The order we found is given by the following interpretation: Polynomial interpretation : POL(#0) = 0 POL(#COMPARE(x_1, x_2)) = 0 POL(#EQ) = [1] POL(#GT) = [1] POL(#LESS(x_1, x_2)) = 0 POL(#LT) = [1] POL(#cklt(x_1)) = [1] POL(#compare(x_1, x_2)) = 0 POL(#false) = [1] POL(#less(x_1, x_2)) = [1] + x_1 + x_2 POL(#neg(x_1)) = 0 POL(#pos(x_1)) = 0 POL(#s(x_1)) = 0 POL(#true) = [1] POL(::(x_1, x_2)) = 0 POL(MERGE(x_1, x_2)) = 0 POL(MERGE#1(x_1, x_2)) = 0 POL(MERGE#2(x_1, x_2, x_3)) = 0 POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0 POL(MERGESORT(x_1)) = 0 POL(MERGESORT#1(x_1)) = 0 POL(MERGESORT#2(x_1, x_2)) = 0 POL(MERGESORT#3(x_1)) = x_1 POL(MSPLIT(x_1)) = 0 POL(MSPLIT#1(x_1)) = 0 POL(MSPLIT#2(x_1, x_2)) = 0 POL(c12(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(c19(x_1)) = x_1 POL(c19(x_1, x_2)) = x_1 + x_2 POL(c21(x_1)) = x_1 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c24(x_1)) = x_1 POL(c26(x_1)) = x_1 POL(c26(x_1, x_2)) = x_1 + x_2 POL(c28(x_1, x_2)) = x_1 + x_2 POL(c29(x_1, x_2)) = x_1 + x_2 POL(c30(x_1)) = x_1 POL(c31(x_1)) = x_1 POL(c33(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(merge(x_1, x_2)) = [1] + x_1 + x_2 POL(merge#1(x_1, x_2)) = [1] + x_1 + x_2 POL(merge#2(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3 POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_3 + x_4 + x_5 POL(mergesort(x_1)) = [1] + x_1 POL(mergesort#1(x_1)) = [1] + x_1 POL(mergesort#2(x_1, x_2)) = [1] + x_1 + x_2 POL(mergesort#3(x_1)) = [1] POL(msplit(x_1)) = [1] + x_1 POL(msplit#1(x_1)) = [1] + x_1 POL(msplit#2(x_1, x_2)) = 0 POL(msplit#3(x_1, x_2, x_3)) = 0 POL(nil) = [1] POL(tuple#2(x_1, x_2)) = x_2 ---------------------------------------- (110) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c29_2, c19_2, c19_1, c26_2, c26_1, c28_2 ---------------------------------------- (111) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) by MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort#1(x0), mergesort#1(z0)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) ---------------------------------------- (112) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2 ---------------------------------------- (113) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) We considered the (Usable) Rules: msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) And the Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) The order we found is given by the following interpretation: Polynomial interpretation : POL(#0) = 0 POL(#COMPARE(x_1, x_2)) = 0 POL(#EQ) = [1] POL(#GT) = [1] POL(#LESS(x_1, x_2)) = 0 POL(#LT) = [1] POL(#cklt(x_1)) = [1] POL(#compare(x_1, x_2)) = 0 POL(#false) = [1] POL(#less(x_1, x_2)) = [1] + x_1 + x_2 POL(#neg(x_1)) = 0 POL(#pos(x_1)) = 0 POL(#s(x_1)) = 0 POL(#true) = [1] POL(::(x_1, x_2)) = 0 POL(MERGE(x_1, x_2)) = 0 POL(MERGE#1(x_1, x_2)) = 0 POL(MERGE#2(x_1, x_2, x_3)) = 0 POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0 POL(MERGESORT(x_1)) = 0 POL(MERGESORT#1(x_1)) = 0 POL(MERGESORT#2(x_1, x_2)) = 0 POL(MERGESORT#3(x_1)) = x_1 POL(MSPLIT(x_1)) = 0 POL(MSPLIT#1(x_1)) = 0 POL(MSPLIT#2(x_1, x_2)) = 0 POL(c12(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(c19(x_1)) = x_1 POL(c19(x_1, x_2)) = x_1 + x_2 POL(c21(x_1)) = x_1 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c24(x_1)) = x_1 POL(c26(x_1)) = x_1 POL(c26(x_1, x_2)) = x_1 + x_2 POL(c28(x_1, x_2)) = x_1 + x_2 POL(c29(x_1, x_2)) = x_1 + x_2 POL(c30(x_1)) = x_1 POL(c31(x_1)) = x_1 POL(c33(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(merge(x_1, x_2)) = [1] + x_1 + x_2 POL(merge#1(x_1, x_2)) = [1] + x_1 + x_2 POL(merge#2(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3 POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_3 + x_4 + x_5 POL(mergesort(x_1)) = [1] + x_1 POL(mergesort#1(x_1)) = [1] + x_1 POL(mergesort#2(x_1, x_2)) = [1] + x_1 + x_2 POL(mergesort#3(x_1)) = [1] POL(msplit(x_1)) = [1] + x_1 POL(msplit#1(x_1)) = [1] + x_1 POL(msplit#2(x_1, x_2)) = 0 POL(msplit#3(x_1, x_2, x_3)) = 0 POL(nil) = [1] POL(tuple#2(x_1, x_2)) = x_1 ---------------------------------------- (114) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2 ---------------------------------------- (115) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) We considered the (Usable) Rules: msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#1(nil) -> tuple#2(nil, nil) msplit(z0) -> msplit#1(z0) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) And the Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) The order we found is given by the following interpretation: Polynomial interpretation : POL(#0) = 0 POL(#COMPARE(x_1, x_2)) = 0 POL(#EQ) = 0 POL(#GT) = 0 POL(#LESS(x_1, x_2)) = 0 POL(#LT) = 0 POL(#cklt(x_1)) = 0 POL(#compare(x_1, x_2)) = 0 POL(#false) = 0 POL(#less(x_1, x_2)) = [3] + [3]x_1 + [3]x_2 POL(#neg(x_1)) = 0 POL(#pos(x_1)) = 0 POL(#s(x_1)) = 0 POL(#true) = 0 POL(::(x_1, x_2)) = [1] + x_2 POL(MERGE(x_1, x_2)) = 0 POL(MERGE#1(x_1, x_2)) = 0 POL(MERGE#2(x_1, x_2, x_3)) = 0 POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0 POL(MERGESORT(x_1)) = [2]x_1 POL(MERGESORT#1(x_1)) = [2]x_1 POL(MERGESORT#2(x_1, x_2)) = [2] + [2]x_1 POL(MERGESORT#3(x_1)) = [2]x_1 POL(MSPLIT(x_1)) = 0 POL(MSPLIT#1(x_1)) = 0 POL(MSPLIT#2(x_1, x_2)) = 0 POL(c12(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(c19(x_1)) = x_1 POL(c19(x_1, x_2)) = x_1 + x_2 POL(c21(x_1)) = x_1 POL(c22(x_1)) = x_1 POL(c23(x_1)) = x_1 POL(c24(x_1)) = x_1 POL(c26(x_1)) = x_1 POL(c26(x_1, x_2)) = x_1 + x_2 POL(c28(x_1, x_2)) = x_1 + x_2 POL(c29(x_1, x_2)) = x_1 + x_2 POL(c30(x_1)) = x_1 POL(c31(x_1)) = x_1 POL(c33(x_1)) = x_1 POL(c8(x_1)) = x_1 POL(merge(x_1, x_2)) = [3] POL(merge#1(x_1, x_2)) = [3] + [3]x_1 + [3]x_2 POL(merge#2(x_1, x_2, x_3)) = [3] + [3]x_1 + [3]x_2 + [3]x_3 POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [3] + [3]x_2 + [3]x_3 + [3]x_4 + [3]x_5 POL(mergesort(x_1)) = [3]x_1 POL(mergesort#1(x_1)) = [3]x_1 POL(mergesort#2(x_1, x_2)) = [3]x_1 + [3]x_2 POL(mergesort#3(x_1)) = [3] POL(msplit(x_1)) = x_1 POL(msplit#1(x_1)) = x_1 POL(msplit#2(x_1, x_2)) = [1] + x_1 POL(msplit#3(x_1, x_2, x_3)) = [2] + x_1 POL(nil) = 0 POL(tuple#2(x_1, x_2)) = x_1 + x_2 ---------------------------------------- (116) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2 ---------------------------------------- (117) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) by #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) ---------------------------------------- (118) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1 ---------------------------------------- (119) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) by MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) ---------------------------------------- (120) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1 ---------------------------------------- (121) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) by #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) ---------------------------------------- (122) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1 ---------------------------------------- (123) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) by MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) ---------------------------------------- (124) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1 ---------------------------------------- (125) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) by MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) ---------------------------------------- (126) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1 ---------------------------------------- (127) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) by MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) ---------------------------------------- (128) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1 ---------------------------------------- (129) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) by MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) ---------------------------------------- (130) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1 ---------------------------------------- (131) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) by MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) ---------------------------------------- (132) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1 ---------------------------------------- (133) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) by MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) ---------------------------------------- (134) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1 ---------------------------------------- (135) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) by MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) ---------------------------------------- (136) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1 ---------------------------------------- (137) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) by MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) ---------------------------------------- (138) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1 Compound Symbols: c14_1, c16_1, c17_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1 ---------------------------------------- (139) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) by MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) ---------------------------------------- (140) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, MERGE#3_5 Compound Symbols: c14_1, c16_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1 ---------------------------------------- (141) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) by MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) ---------------------------------------- (142) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, MERGE#3_5 Compound Symbols: c14_1, c16_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1 ---------------------------------------- (143) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: MERGE#3(#true, #s(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) ---------------------------------------- (144) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #COMPARE_2, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, MERGE#3_5 Compound Symbols: c14_1, c16_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1 ---------------------------------------- (145) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) by #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) ---------------------------------------- (146) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) S tuples: MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5 Compound Symbols: c16_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1 ---------------------------------------- (147) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) by MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) ---------------------------------------- (148) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) S tuples: MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2 Compound Symbols: c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1 ---------------------------------------- (149) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (150) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) S tuples: MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2 Compound Symbols: c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c28_1, c29_1 ---------------------------------------- (151) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) by MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) ---------------------------------------- (152) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) S tuples: MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2 Compound Symbols: c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c28_1, c29_1, c17_1 ---------------------------------------- (153) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) by MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) ---------------------------------------- (154) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) S tuples: MERGESORT(z0) -> c23(MERGESORT#1(z0)) MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2 Compound Symbols: c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c28_1, c29_1, c17_1, c26_2 ---------------------------------------- (155) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace MERGESORT(z0) -> c23(MERGESORT#1(z0)) by MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) ---------------------------------------- (156) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) S tuples: MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1 Compound Symbols: c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c28_1, c29_1, c17_1, c26_2, c23_1 ---------------------------------------- (157) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil)) ---------------------------------------- (158) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) S tuples: MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1 Compound Symbols: c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1 ---------------------------------------- (159) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (160) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) S tuples: MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1 Compound Symbols: c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1 ---------------------------------------- (161) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) by MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) ---------------------------------------- (162) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) S tuples: MSPLIT(z0) -> c30(MSPLIT#1(z0)) MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1 Compound Symbols: c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1 ---------------------------------------- (163) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace MSPLIT(z0) -> c30(MSPLIT#1(z0)) by MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) ---------------------------------------- (164) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) S tuples: MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1 Compound Symbols: c31_1, c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1 ---------------------------------------- (165) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) by MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) ---------------------------------------- (166) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) S tuples: MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1 Compound Symbols: c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1 ---------------------------------------- (167) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) by MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) ---------------------------------------- (168) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) S tuples: MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1 Compound Symbols: c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1 ---------------------------------------- (169) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) by MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) ---------------------------------------- (170) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) S tuples: MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1 Compound Symbols: c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1 ---------------------------------------- (171) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) by MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) ---------------------------------------- (172) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) S tuples: MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) K tuples: #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1 Compound Symbols: c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1 ---------------------------------------- (173) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) by #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) ---------------------------------------- (174) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0))) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0))) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0))) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0))) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0)) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) S tuples: MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) K tuples: MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2 Compound Symbols: c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1, c15_1 ---------------------------------------- (175) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 9 trailing tuple parts ---------------------------------------- (176) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0)) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1)) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1)) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1)) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1)) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1)) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0)) S tuples: MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) K tuples: MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2 Compound Symbols: c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1, c15_1 ---------------------------------------- (177) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) by MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) ---------------------------------------- (178) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0)) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1)) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1)) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1)) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1)) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1)) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0)) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) S tuples: MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) K tuples: MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1 ---------------------------------------- (179) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) by MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) ---------------------------------------- (180) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0)) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1)) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1)) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1)) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1)) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1)) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0)) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) S tuples: MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) K tuples: MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1 ---------------------------------------- (181) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) by MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2)) ---------------------------------------- (182) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0)) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1)) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1)) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1)) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1)) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1)) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0)) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2)) S tuples: MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) K tuples: MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1 ---------------------------------------- (183) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) by MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1)))) MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1)))) MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1)))) MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1)))) MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1)))) MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) ---------------------------------------- (184) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0)) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1)) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1)) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1)) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1)) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1)) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0)) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2)) MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1)))) MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1)))) MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1)))) MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1)))) MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1)))) MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) S tuples: MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) K tuples: MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c19_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1 ---------------------------------------- (185) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) by MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) ---------------------------------------- (186) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0)) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1)) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1)) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1)) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1)) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1)) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0)) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2)) MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1)))) MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1)))) MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1)))) MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1)))) MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1)))) MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) S tuples: MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) K tuples: MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c19_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1, c26_2 ---------------------------------------- (187) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) by #COMPARE(#neg(#neg(#neg(y1))), #neg(#neg(#neg(y0)))) -> c8(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#neg(#neg(#pos(y1))), #neg(#neg(#pos(y0)))) -> c8(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#neg(#neg(#s(y1))), #neg(#neg(#s(y0)))) -> c8(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) ---------------------------------------- (188) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0)) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1)) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1)) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1)) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1)) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1)) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0)) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2)) MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1)))) MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1)))) MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1)))) MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1)))) MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1)))) MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) #COMPARE(#neg(#neg(#neg(y1))), #neg(#neg(#neg(y0)))) -> c8(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#neg(#neg(#pos(y1))), #neg(#neg(#pos(y0)))) -> c8(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#neg(#neg(#s(y1))), #neg(#neg(#s(y0)))) -> c8(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) S tuples: MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) K tuples: MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c19_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1, c26_2 ---------------------------------------- (189) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) by MERGESORT#3(tuple#2(z0, nil)) -> c29(MERGE(mergesort#1(z0), nil)) ---------------------------------------- (190) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0)) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1)) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1)) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1)) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1)) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1)) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0)) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2)) MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1)))) MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1)))) MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1)))) MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1)))) MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1)))) MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) #COMPARE(#neg(#neg(#neg(y1))), #neg(#neg(#neg(y0)))) -> c8(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#neg(#neg(#pos(y1))), #neg(#neg(#pos(y0)))) -> c8(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#neg(#neg(#s(y1))), #neg(#neg(#s(y0)))) -> c8(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGESORT#3(tuple#2(z0, nil)) -> c29(MERGE(mergesort#1(z0), nil)) S tuples: MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) K tuples: MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c19_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1, c26_2 ---------------------------------------- (191) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) by #COMPARE(#neg(#pos(#pos(y1))), #neg(#pos(#pos(y0)))) -> c8(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#neg(#pos(#s(y1))), #neg(#pos(#s(y0)))) -> c8(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#neg(#pos(#neg(#neg(y1)))), #neg(#pos(#neg(#neg(y0))))) -> c8(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#neg(#pos(#neg(#pos(y1)))), #neg(#pos(#neg(#pos(y0))))) -> c8(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#neg(#pos(#neg(#s(y1)))), #neg(#pos(#neg(#s(y0))))) -> c8(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) ---------------------------------------- (192) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0)) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1)) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1)) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1)) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1)) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1)) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0)) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2)) MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1)))) MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1)))) MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1)))) MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1)))) MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1)))) MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) #COMPARE(#neg(#neg(#neg(y1))), #neg(#neg(#neg(y0)))) -> c8(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#neg(#neg(#pos(y1))), #neg(#neg(#pos(y0)))) -> c8(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#neg(#neg(#s(y1))), #neg(#neg(#s(y0)))) -> c8(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGESORT#3(tuple#2(z0, nil)) -> c29(MERGE(mergesort#1(z0), nil)) #COMPARE(#neg(#pos(#pos(y1))), #neg(#pos(#pos(y0)))) -> c8(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#neg(#pos(#s(y1))), #neg(#pos(#s(y0)))) -> c8(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#neg(#pos(#neg(#neg(y1)))), #neg(#pos(#neg(#neg(y0))))) -> c8(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#neg(#pos(#neg(#pos(y1)))), #neg(#pos(#neg(#pos(y0))))) -> c8(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#neg(#pos(#neg(#s(y1)))), #neg(#pos(#neg(#s(y0))))) -> c8(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) S tuples: MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) K tuples: MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c19_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1, c26_2 ---------------------------------------- (193) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) by #COMPARE(#neg(#s(#s(y1))), #neg(#s(#s(y0)))) -> c8(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #COMPARE(#neg(#s(#neg(#neg(y1)))), #neg(#s(#neg(#neg(y0))))) -> c8(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #COMPARE(#neg(#s(#neg(#pos(y1)))), #neg(#s(#neg(#pos(y0))))) -> c8(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #COMPARE(#neg(#s(#neg(#s(y1)))), #neg(#s(#neg(#s(y0))))) -> c8(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #COMPARE(#neg(#s(#pos(#pos(y1)))), #neg(#s(#pos(#pos(y0))))) -> c8(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #COMPARE(#neg(#s(#pos(#s(y1)))), #neg(#s(#pos(#s(y0))))) -> c8(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #COMPARE(#neg(#s(#pos(#neg(#neg(y1))))), #neg(#s(#pos(#neg(#neg(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #COMPARE(#neg(#s(#pos(#neg(#pos(y1))))), #neg(#s(#pos(#neg(#pos(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #COMPARE(#neg(#s(#pos(#neg(#s(y1))))), #neg(#s(#pos(#neg(#s(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) ---------------------------------------- (194) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0)) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1)) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1)) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1)) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1)) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1)) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0)) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2)) MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1)))) MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1)))) MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1)))) MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1)))) MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1)))) MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) #COMPARE(#neg(#neg(#neg(y1))), #neg(#neg(#neg(y0)))) -> c8(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#neg(#neg(#pos(y1))), #neg(#neg(#pos(y0)))) -> c8(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#neg(#neg(#s(y1))), #neg(#neg(#s(y0)))) -> c8(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGESORT#3(tuple#2(z0, nil)) -> c29(MERGE(mergesort#1(z0), nil)) #COMPARE(#neg(#pos(#pos(y1))), #neg(#pos(#pos(y0)))) -> c8(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#neg(#pos(#s(y1))), #neg(#pos(#s(y0)))) -> c8(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#neg(#pos(#neg(#neg(y1)))), #neg(#pos(#neg(#neg(y0))))) -> c8(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#neg(#pos(#neg(#pos(y1)))), #neg(#pos(#neg(#pos(y0))))) -> c8(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#neg(#pos(#neg(#s(y1)))), #neg(#pos(#neg(#s(y0))))) -> c8(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #COMPARE(#neg(#s(#s(y1))), #neg(#s(#s(y0)))) -> c8(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #COMPARE(#neg(#s(#neg(#neg(y1)))), #neg(#s(#neg(#neg(y0))))) -> c8(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #COMPARE(#neg(#s(#neg(#pos(y1)))), #neg(#s(#neg(#pos(y0))))) -> c8(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #COMPARE(#neg(#s(#neg(#s(y1)))), #neg(#s(#neg(#s(y0))))) -> c8(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #COMPARE(#neg(#s(#pos(#pos(y1)))), #neg(#s(#pos(#pos(y0))))) -> c8(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #COMPARE(#neg(#s(#pos(#s(y1)))), #neg(#s(#pos(#s(y0))))) -> c8(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #COMPARE(#neg(#s(#pos(#neg(#neg(y1))))), #neg(#s(#pos(#neg(#neg(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #COMPARE(#neg(#s(#pos(#neg(#pos(y1))))), #neg(#s(#pos(#neg(#pos(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #COMPARE(#neg(#s(#pos(#neg(#s(y1))))), #neg(#s(#pos(#neg(#s(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) S tuples: MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) K tuples: MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c19_2, c26_1, c28_2, c29_2, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1, c26_2, c8_1 ---------------------------------------- (195) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) by #COMPARE(#pos(#pos(#pos(y0))), #pos(#pos(#pos(y1)))) -> c12(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#pos(#pos(#s(y0))), #pos(#pos(#s(y1)))) -> c12(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#pos(#pos(#neg(#neg(y0)))), #pos(#pos(#neg(#neg(y1))))) -> c12(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#pos(#pos(#neg(#pos(y0)))), #pos(#pos(#neg(#pos(y1))))) -> c12(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#pos(#pos(#neg(#s(y0)))), #pos(#pos(#neg(#s(y1))))) -> c12(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) ---------------------------------------- (196) Obligation: Complexity Dependency Tuples Problem Rules: #cklt(#EQ) -> #false #cklt(#GT) -> #false #cklt(#LT) -> #true #compare(#0, #0) -> #EQ #compare(#0, #neg(z0)) -> #GT #compare(#0, #pos(z0)) -> #LT #compare(#0, #s(z0)) -> #LT #compare(#neg(z0), #0) -> #LT #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0) #compare(#neg(z0), #pos(z1)) -> #LT #compare(#pos(z0), #0) -> #GT #compare(#pos(z0), #neg(z1)) -> #GT #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1) #compare(#s(z0), #0) -> #GT #compare(#s(z0), #s(z1)) -> #compare(z0, z1) #less(z0, z1) -> #cklt(#compare(z0, z1)) merge(z0, z1) -> merge#1(z0, z1) merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1) merge#1(nil, z0) -> z0 merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1) merge#2(nil, z0, z1) -> ::(z0, z1) merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3)) merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3))) mergesort(z0) -> mergesort#1(z0) mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0) mergesort#1(nil) -> nil mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1)))) mergesort#2(nil, z0) -> ::(z0, nil) mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1)) msplit(z0) -> msplit#1(z0) msplit#1(::(z0, z1)) -> msplit#2(z1, z0) msplit#1(nil) -> tuple#2(nil, nil) msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0) msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil) msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1)) Tuples: MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1))) MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1))) MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1))) MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1))) #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1))) #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0)) MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1)) MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1)) MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1)) MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0)) MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1)) MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0)) MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1)) MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0)) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2)) MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1)))) MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1)))) MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1)))) MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1)))) MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1)))) MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1)))) MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) #COMPARE(#neg(#neg(#neg(y1))), #neg(#neg(#neg(y0)))) -> c8(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #COMPARE(#neg(#neg(#pos(y1))), #neg(#neg(#pos(y0)))) -> c8(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #COMPARE(#neg(#neg(#s(y1))), #neg(#neg(#s(y0)))) -> c8(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) MERGESORT#3(tuple#2(z0, nil)) -> c29(MERGE(mergesort#1(z0), nil)) #COMPARE(#neg(#pos(#pos(y1))), #neg(#pos(#pos(y0)))) -> c8(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#neg(#pos(#s(y1))), #neg(#pos(#s(y0)))) -> c8(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#neg(#pos(#neg(#neg(y1)))), #neg(#pos(#neg(#neg(y0))))) -> c8(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#neg(#pos(#neg(#pos(y1)))), #neg(#pos(#neg(#pos(y0))))) -> c8(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#neg(#pos(#neg(#s(y1)))), #neg(#pos(#neg(#s(y0))))) -> c8(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #COMPARE(#neg(#s(#s(y1))), #neg(#s(#s(y0)))) -> c8(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #COMPARE(#neg(#s(#neg(#neg(y1)))), #neg(#s(#neg(#neg(y0))))) -> c8(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #COMPARE(#neg(#s(#neg(#pos(y1)))), #neg(#s(#neg(#pos(y0))))) -> c8(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #COMPARE(#neg(#s(#neg(#s(y1)))), #neg(#s(#neg(#s(y0))))) -> c8(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #COMPARE(#neg(#s(#pos(#pos(y1)))), #neg(#s(#pos(#pos(y0))))) -> c8(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #COMPARE(#neg(#s(#pos(#s(y1)))), #neg(#s(#pos(#s(y0))))) -> c8(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #COMPARE(#neg(#s(#pos(#neg(#neg(y1))))), #neg(#s(#pos(#neg(#neg(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #COMPARE(#neg(#s(#pos(#neg(#pos(y1))))), #neg(#s(#pos(#neg(#pos(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #COMPARE(#neg(#s(#pos(#neg(#s(y1))))), #neg(#s(#pos(#neg(#s(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) #COMPARE(#pos(#pos(#pos(y0))), #pos(#pos(#pos(y1)))) -> c12(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #COMPARE(#pos(#pos(#s(y0))), #pos(#pos(#s(y1)))) -> c12(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #COMPARE(#pos(#pos(#neg(#neg(y0)))), #pos(#pos(#neg(#neg(y1))))) -> c12(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #COMPARE(#pos(#pos(#neg(#pos(y0)))), #pos(#pos(#neg(#pos(y1))))) -> c12(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #COMPARE(#pos(#pos(#neg(#s(y0)))), #pos(#pos(#neg(#s(y1))))) -> c12(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) S tuples: MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0)) MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1)) MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1)) MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1)) MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1)) MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1)) MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1)) MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1)) MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1)) MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1)) MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1)) MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1)) MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1))) MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0)) MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1))) MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0)) MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1))) MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1))) MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2))) MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) K tuples: MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1)))) MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1)) MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0)) MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1)) MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0)) MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1)) MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0)) MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1)) MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1))) MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1))) MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1))) MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1))) MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0))) MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1))) MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1)) MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1)))) #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1)))) #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1)))) #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1)))) #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1)))) #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1))))) #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1))))) #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1))))) #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1)))) #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1))))) #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1))))) #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1))))) #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1))))) #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1))))) #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1)))))) #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1)))))) #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1)))))) Defined Rule Symbols: #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2 Defined Pair Symbols: MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2 Compound Symbols: c19_2, c26_1, c28_2, c29_2, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1, c26_2, c8_1