KILLED proof of input_rap1UPs9Y7.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), 217 ms] (2) CpxRelTRS (3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms] (4) CpxTRS (5) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms] (6) CpxRelTRS (7) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms] (8) CpxWeightedTrs (9) CpxWeightedTrsRenamingProof [BOTH BOUNDS(ID, ID), 0 ms] (10) CpxWeightedTrs (11) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms] (12) CpxTypedWeightedTrs (13) CompletionProof [UPPER BOUND(ID), 0 ms] (14) CpxTypedWeightedCompleteTrs (15) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (16) CpxTypedWeightedCompleteTrs (17) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 16 ms] (18) CpxRNTS (19) SimplificationProof [BOTH BOUNDS(ID, ID), 21 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), 136 ms] (26) CpxRNTS (27) IntTrsBoundProof [UPPER BOUND(ID), 16 ms] (28) CpxRNTS (29) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (30) CpxRNTS (31) IntTrsBoundProof [UPPER BOUND(ID), 459 ms] (32) CpxRNTS (33) IntTrsBoundProof [UPPER BOUND(ID), 118 ms] (34) CpxRNTS (35) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (36) CpxRNTS (37) IntTrsBoundProof [UPPER BOUND(ID), 323 ms] (38) CpxRNTS (39) IntTrsBoundProof [UPPER BOUND(ID), 96 ms] (40) CpxRNTS (41) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (42) CpxRNTS (43) IntTrsBoundProof [UPPER BOUND(ID), 2025 ms] (44) CpxRNTS (45) IntTrsBoundProof [UPPER BOUND(ID), 631 ms] (46) CpxRNTS (47) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (48) CpxRNTS (49) IntTrsBoundProof [UPPER BOUND(ID), 7945 ms] (50) CpxRNTS (51) IntTrsBoundProof [UPPER BOUND(ID), 2182 ms] (52) CpxRNTS (53) CompletionProof [UPPER BOUND(ID), 0 ms] (54) CpxTypedWeightedCompleteTrs (55) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms] (56) CpxRNTS (57) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms] (58) CdtProblem (59) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (60) CdtProblem (61) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (62) CdtProblem (63) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (64) CdtProblem (65) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (66) CdtProblem (67) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (68) CdtProblem (69) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (70) CdtProblem (71) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (72) CdtProblem (73) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (74) CdtProblem (75) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 31 ms] (76) CdtProblem (77) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (78) CdtProblem (79) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (80) CdtProblem (81) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (82) CdtProblem (83) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (84) CdtProblem (85) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (86) CdtProblem (87) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (88) CdtProblem (89) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 32 ms] (90) CdtProblem (91) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (92) CdtProblem (93) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (94) CdtProblem (95) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (96) CdtProblem (97) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (98) CdtProblem (99) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (100) CdtProblem (101) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (102) CdtProblem (103) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (104) CdtProblem (105) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (106) CdtProblem (107) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (108) CdtProblem (109) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (110) CdtProblem (111) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (112) CdtProblem (113) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (114) CdtProblem (115) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (116) CdtProblem (117) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (118) CdtProblem (119) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (120) CdtProblem (121) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (122) CdtProblem (123) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (124) CdtProblem (125) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (126) CdtProblem (127) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (128) CdtProblem (129) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (130) CdtProblem (131) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (132) CdtProblem (133) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (134) CdtProblem (135) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (136) CdtProblem (137) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (138) CdtProblem (139) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (140) CdtProblem (141) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (142) CdtProblem (143) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 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) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (150) CdtProblem (151) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 1 ms] (152) CdtProblem (153) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (154) CdtProblem (155) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (156) CdtProblem (157) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (158) CdtProblem (159) CdtForwardInstantiationProof [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) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (168) CdtProblem (169) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (170) CdtProblem (171) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (172) 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: minsort(Cons(x, xs)) -> appmin(x, xs, Cons(x, xs)) minsort(Nil) -> Nil appmin(min, Cons(x, xs), xs') -> appmin[Ite][True][Ite](<(x, min), min, Cons(x, xs), xs') appmin(min, Nil, xs) -> Cons(min, minsort(remove(min, xs))) notEmpty(Cons(x, xs)) -> True notEmpty(Nil) -> False remove(x', Cons(x, xs)) -> remove[Ite](!EQ(x', x), x', Cons(x, xs)) The (relative) TRS S consists of the following rules: !EQ(S(x), S(y)) -> !EQ(x, y) !EQ(0, S(y)) -> False !EQ(S(x), 0) -> False !EQ(0, 0) -> True <(S(x), S(y)) -> <(x, y) <(0, S(y)) -> True <(x, 0) -> False remove[Ite](False, x', Cons(x, xs)) -> Cons(x, remove(x', xs)) appmin[Ite][True][Ite](True, min, Cons(x, xs), xs') -> appmin(x, xs, xs') remove[Ite](True, x', Cons(x, xs)) -> xs appmin[Ite][True][Ite](False, min, Cons(x, xs), xs') -> appmin(min, xs, xs') 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: minsort(Cons(x, xs)) -> appmin(x, xs, Cons(x, xs)) minsort(Nil) -> Nil appmin(min, Cons(x, xs), xs') -> appmin[Ite][True][Ite](<(x, min), min, Cons(x, xs), xs') appmin(min, Nil, xs) -> Cons(min, minsort(remove(min, xs))) notEmpty(Cons(x, xs)) -> True notEmpty(Nil) -> False remove(x', Cons(x, xs)) -> remove[Ite](!EQ(x', x), x', Cons(x, xs)) The (relative) TRS S consists of the following rules: !EQ(S(x), S(y)) -> !EQ(x, y) !EQ(0, S(y)) -> False !EQ(S(x), 0) -> False !EQ(0, 0) -> True <(S(x), S(y)) -> <(x, y) <(0, S(y)) -> True <(x, 0) -> False remove[Ite](False, x', Cons(x, xs)) -> Cons(x, remove(x', xs)) appmin[Ite][True][Ite](True, min, Cons(x, xs), xs') -> appmin(x, xs, xs') remove[Ite](True, x', Cons(x, xs)) -> xs appmin[Ite][True][Ite](False, min, Cons(x, xs), xs') -> appmin(min, xs, xs') Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (3) RelTrsToTrsProof (UPPER BOUND(ID)) transformed relative TRS to TRS ---------------------------------------- (4) Obligation: The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF). The TRS R consists of the following rules: minsort(Cons(x, xs)) -> appmin(x, xs, Cons(x, xs)) minsort(Nil) -> Nil appmin(min, Cons(x, xs), xs') -> appmin[Ite][True][Ite](<(x, min), min, Cons(x, xs), xs') appmin(min, Nil, xs) -> Cons(min, minsort(remove(min, xs))) notEmpty(Cons(x, xs)) -> True notEmpty(Nil) -> False remove(x', Cons(x, xs)) -> remove[Ite](!EQ(x', x), x', Cons(x, xs)) !EQ(S(x), S(y)) -> !EQ(x, y) !EQ(0, S(y)) -> False !EQ(S(x), 0) -> False !EQ(0, 0) -> True <(S(x), S(y)) -> <(x, y) <(0, S(y)) -> True <(x, 0) -> False remove[Ite](False, x', Cons(x, xs)) -> Cons(x, remove(x', xs)) appmin[Ite][True][Ite](True, min, Cons(x, xs), xs') -> appmin(x, xs, xs') remove[Ite](True, x', Cons(x, xs)) -> xs appmin[Ite][True][Ite](False, min, Cons(x, xs), xs') -> appmin(min, xs, xs') S is empty. Rewrite Strategy: PARALLEL_INNERMOST ---------------------------------------- (5) RenamingProof (BOTH BOUNDS(ID, ID)) Renamed function symbols to avoid clashes with predefined symbol. ---------------------------------------- (6) 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: minsort(Cons(x, xs)) -> appmin(x, xs, Cons(x, xs)) minsort(Nil) -> Nil appmin(min, Cons(x, xs), xs') -> appmin[Ite][True][Ite](<(x, min), min, Cons(x, xs), xs') appmin(min, Nil, xs) -> Cons(min, minsort(remove(min, xs))) notEmpty(Cons(x, xs)) -> True notEmpty(Nil) -> False remove(x', Cons(x, xs)) -> remove[Ite](!EQ(x', x), x', Cons(x, xs)) The (relative) TRS S consists of the following rules: !EQ(S(x), S(y)) -> !EQ(x, y) !EQ(0', S(y)) -> False !EQ(S(x), 0') -> False !EQ(0', 0') -> True <(S(x), S(y)) -> <(x, y) <(0', S(y)) -> True <(x, 0') -> False remove[Ite](False, x', Cons(x, xs)) -> Cons(x, remove(x', xs)) appmin[Ite][True][Ite](True, min, Cons(x, xs), xs') -> appmin(x, xs, xs') remove[Ite](True, x', Cons(x, xs)) -> xs appmin[Ite][True][Ite](False, min, Cons(x, xs), xs') -> appmin(min, xs, xs') 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: minsort(Cons(x, xs)) -> appmin(x, xs, Cons(x, xs)) [1] minsort(Nil) -> Nil [1] appmin(min, Cons(x, xs), xs') -> appmin[Ite][True][Ite](<(x, min), min, Cons(x, xs), xs') [1] appmin(min, Nil, xs) -> Cons(min, minsort(remove(min, xs))) [1] notEmpty(Cons(x, xs)) -> True [1] notEmpty(Nil) -> False [1] remove(x', Cons(x, xs)) -> remove[Ite](!EQ(x', x), x', Cons(x, xs)) [1] !EQ(S(x), S(y)) -> !EQ(x, y) [0] !EQ(0, S(y)) -> False [0] !EQ(S(x), 0) -> False [0] !EQ(0, 0) -> True [0] <(S(x), S(y)) -> <(x, y) [0] <(0, S(y)) -> True [0] <(x, 0) -> False [0] remove[Ite](False, x', Cons(x, xs)) -> Cons(x, remove(x', xs)) [0] appmin[Ite][True][Ite](True, min, Cons(x, xs), xs') -> appmin(x, xs, xs') [0] remove[Ite](True, x', Cons(x, xs)) -> xs [0] appmin[Ite][True][Ite](False, min, Cons(x, xs), xs') -> appmin(min, xs, xs') [0] Rewrite Strategy: INNERMOST ---------------------------------------- (9) CpxWeightedTrsRenamingProof (BOTH BOUNDS(ID, ID)) Renamed defined symbols to avoid conflicts with arithmetic symbols: < => lt ---------------------------------------- (10) 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: minsort(Cons(x, xs)) -> appmin(x, xs, Cons(x, xs)) [1] minsort(Nil) -> Nil [1] appmin(min, Cons(x, xs), xs') -> appmin[Ite][True][Ite](lt(x, min), min, Cons(x, xs), xs') [1] appmin(min, Nil, xs) -> Cons(min, minsort(remove(min, xs))) [1] notEmpty(Cons(x, xs)) -> True [1] notEmpty(Nil) -> False [1] remove(x', Cons(x, xs)) -> remove[Ite](!EQ(x', x), x', Cons(x, xs)) [1] !EQ(S(x), S(y)) -> !EQ(x, y) [0] !EQ(0, S(y)) -> False [0] !EQ(S(x), 0) -> False [0] !EQ(0, 0) -> True [0] lt(S(x), S(y)) -> lt(x, y) [0] lt(0, S(y)) -> True [0] lt(x, 0) -> False [0] remove[Ite](False, x', Cons(x, xs)) -> Cons(x, remove(x', xs)) [0] appmin[Ite][True][Ite](True, min, Cons(x, xs), xs') -> appmin(x, xs, xs') [0] remove[Ite](True, x', Cons(x, xs)) -> xs [0] appmin[Ite][True][Ite](False, min, Cons(x, xs), xs') -> appmin(min, xs, xs') [0] Rewrite Strategy: INNERMOST ---------------------------------------- (11) TypeInferenceProof (BOTH BOUNDS(ID, ID)) Infered types. ---------------------------------------- (12) Obligation: Runtime Complexity Weighted TRS with Types. The TRS R consists of the following rules: minsort(Cons(x, xs)) -> appmin(x, xs, Cons(x, xs)) [1] minsort(Nil) -> Nil [1] appmin(min, Cons(x, xs), xs') -> appmin[Ite][True][Ite](lt(x, min), min, Cons(x, xs), xs') [1] appmin(min, Nil, xs) -> Cons(min, minsort(remove(min, xs))) [1] notEmpty(Cons(x, xs)) -> True [1] notEmpty(Nil) -> False [1] remove(x', Cons(x, xs)) -> remove[Ite](!EQ(x', x), x', Cons(x, xs)) [1] !EQ(S(x), S(y)) -> !EQ(x, y) [0] !EQ(0, S(y)) -> False [0] !EQ(S(x), 0) -> False [0] !EQ(0, 0) -> True [0] lt(S(x), S(y)) -> lt(x, y) [0] lt(0, S(y)) -> True [0] lt(x, 0) -> False [0] remove[Ite](False, x', Cons(x, xs)) -> Cons(x, remove(x', xs)) [0] appmin[Ite][True][Ite](True, min, Cons(x, xs), xs') -> appmin(x, xs, xs') [0] remove[Ite](True, x', Cons(x, xs)) -> xs [0] appmin[Ite][True][Ite](False, min, Cons(x, xs), xs') -> appmin(min, xs, xs') [0] The TRS has the following type information: minsort :: Cons:Nil -> Cons:Nil Cons :: S:0 -> Cons:Nil -> Cons:Nil appmin :: S:0 -> Cons:Nil -> Cons:Nil -> Cons:Nil Nil :: Cons:Nil appmin[Ite][True][Ite] :: True:False -> S:0 -> Cons:Nil -> Cons:Nil -> Cons:Nil lt :: S:0 -> S:0 -> True:False remove :: S:0 -> Cons:Nil -> Cons:Nil notEmpty :: Cons:Nil -> True:False True :: True:False False :: True:False remove[Ite] :: True:False -> S:0 -> Cons:Nil -> Cons:Nil !EQ :: S:0 -> S:0 -> True:False S :: S:0 -> S:0 0 :: S:0 Rewrite Strategy: INNERMOST ---------------------------------------- (13) 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: minsort_1 appmin_3 notEmpty_1 (c) The following functions are completely defined: remove_2 !EQ_2 lt_2 remove[Ite]_3 appmin[Ite][True][Ite]_4 Due to the following rules being added: !EQ(v0, v1) -> null_!EQ [0] lt(v0, v1) -> null_lt [0] remove[Ite](v0, v1, v2) -> Nil [0] appmin[Ite][True][Ite](v0, v1, v2, v3) -> Nil [0] remove(v0, v1) -> Nil [0] And the following fresh constants: null_!EQ, null_lt ---------------------------------------- (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: minsort(Cons(x, xs)) -> appmin(x, xs, Cons(x, xs)) [1] minsort(Nil) -> Nil [1] appmin(min, Cons(x, xs), xs') -> appmin[Ite][True][Ite](lt(x, min), min, Cons(x, xs), xs') [1] appmin(min, Nil, xs) -> Cons(min, minsort(remove(min, xs))) [1] notEmpty(Cons(x, xs)) -> True [1] notEmpty(Nil) -> False [1] remove(x', Cons(x, xs)) -> remove[Ite](!EQ(x', x), x', Cons(x, xs)) [1] !EQ(S(x), S(y)) -> !EQ(x, y) [0] !EQ(0, S(y)) -> False [0] !EQ(S(x), 0) -> False [0] !EQ(0, 0) -> True [0] lt(S(x), S(y)) -> lt(x, y) [0] lt(0, S(y)) -> True [0] lt(x, 0) -> False [0] remove[Ite](False, x', Cons(x, xs)) -> Cons(x, remove(x', xs)) [0] appmin[Ite][True][Ite](True, min, Cons(x, xs), xs') -> appmin(x, xs, xs') [0] remove[Ite](True, x', Cons(x, xs)) -> xs [0] appmin[Ite][True][Ite](False, min, Cons(x, xs), xs') -> appmin(min, xs, xs') [0] !EQ(v0, v1) -> null_!EQ [0] lt(v0, v1) -> null_lt [0] remove[Ite](v0, v1, v2) -> Nil [0] appmin[Ite][True][Ite](v0, v1, v2, v3) -> Nil [0] remove(v0, v1) -> Nil [0] The TRS has the following type information: minsort :: Cons:Nil -> Cons:Nil Cons :: S:0 -> Cons:Nil -> Cons:Nil appmin :: S:0 -> Cons:Nil -> Cons:Nil -> Cons:Nil Nil :: Cons:Nil appmin[Ite][True][Ite] :: True:False:null_!EQ:null_lt -> S:0 -> Cons:Nil -> Cons:Nil -> Cons:Nil lt :: S:0 -> S:0 -> True:False:null_!EQ:null_lt remove :: S:0 -> Cons:Nil -> Cons:Nil notEmpty :: Cons:Nil -> True:False:null_!EQ:null_lt True :: True:False:null_!EQ:null_lt False :: True:False:null_!EQ:null_lt remove[Ite] :: True:False:null_!EQ:null_lt -> S:0 -> Cons:Nil -> Cons:Nil !EQ :: S:0 -> S:0 -> True:False:null_!EQ:null_lt S :: S:0 -> S:0 0 :: S:0 null_!EQ :: True:False:null_!EQ:null_lt null_lt :: True:False:null_!EQ:null_lt Rewrite Strategy: INNERMOST ---------------------------------------- (15) NarrowingProof (BOTH BOUNDS(ID, ID)) Narrowed the inner basic terms of all right-hand sides by a single narrowing step. ---------------------------------------- (16) 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: minsort(Cons(x, xs)) -> appmin(x, xs, Cons(x, xs)) [1] minsort(Nil) -> Nil [1] appmin(S(y'), Cons(S(x''), xs), xs') -> appmin[Ite][True][Ite](lt(x'', y'), S(y'), Cons(S(x''), xs), xs') [1] appmin(S(y''), Cons(0, xs), xs') -> appmin[Ite][True][Ite](True, S(y''), Cons(0, xs), xs') [1] appmin(0, Cons(x, xs), xs') -> appmin[Ite][True][Ite](False, 0, Cons(x, xs), xs') [1] appmin(min, Cons(x, xs), xs') -> appmin[Ite][True][Ite](null_lt, min, Cons(x, xs), xs') [1] appmin(min, Nil, Cons(x1, xs'')) -> Cons(min, minsort(remove[Ite](!EQ(min, x1), min, Cons(x1, xs'')))) [2] appmin(min, Nil, xs) -> Cons(min, minsort(Nil)) [1] notEmpty(Cons(x, xs)) -> True [1] notEmpty(Nil) -> False [1] remove(S(x2), Cons(S(y1), xs)) -> remove[Ite](!EQ(x2, y1), S(x2), Cons(S(y1), xs)) [1] remove(0, Cons(S(y2), xs)) -> remove[Ite](False, 0, Cons(S(y2), xs)) [1] remove(S(x3), Cons(0, xs)) -> remove[Ite](False, S(x3), Cons(0, xs)) [1] remove(0, Cons(0, xs)) -> remove[Ite](True, 0, Cons(0, xs)) [1] remove(x', Cons(x, xs)) -> remove[Ite](null_!EQ, x', Cons(x, xs)) [1] !EQ(S(x), S(y)) -> !EQ(x, y) [0] !EQ(0, S(y)) -> False [0] !EQ(S(x), 0) -> False [0] !EQ(0, 0) -> True [0] lt(S(x), S(y)) -> lt(x, y) [0] lt(0, S(y)) -> True [0] lt(x, 0) -> False [0] remove[Ite](False, x', Cons(x, xs)) -> Cons(x, remove(x', xs)) [0] appmin[Ite][True][Ite](True, min, Cons(x, xs), xs') -> appmin(x, xs, xs') [0] remove[Ite](True, x', Cons(x, xs)) -> xs [0] appmin[Ite][True][Ite](False, min, Cons(x, xs), xs') -> appmin(min, xs, xs') [0] !EQ(v0, v1) -> null_!EQ [0] lt(v0, v1) -> null_lt [0] remove[Ite](v0, v1, v2) -> Nil [0] appmin[Ite][True][Ite](v0, v1, v2, v3) -> Nil [0] remove(v0, v1) -> Nil [0] The TRS has the following type information: minsort :: Cons:Nil -> Cons:Nil Cons :: S:0 -> Cons:Nil -> Cons:Nil appmin :: S:0 -> Cons:Nil -> Cons:Nil -> Cons:Nil Nil :: Cons:Nil appmin[Ite][True][Ite] :: True:False:null_!EQ:null_lt -> S:0 -> Cons:Nil -> Cons:Nil -> Cons:Nil lt :: S:0 -> S:0 -> True:False:null_!EQ:null_lt remove :: S:0 -> Cons:Nil -> Cons:Nil notEmpty :: Cons:Nil -> True:False:null_!EQ:null_lt True :: True:False:null_!EQ:null_lt False :: True:False:null_!EQ:null_lt remove[Ite] :: True:False:null_!EQ:null_lt -> S:0 -> Cons:Nil -> Cons:Nil !EQ :: S:0 -> S:0 -> True:False:null_!EQ:null_lt S :: S:0 -> S:0 0 :: S:0 null_!EQ :: True:False:null_!EQ:null_lt null_lt :: True:False:null_!EQ:null_lt Rewrite Strategy: INNERMOST ---------------------------------------- (17) 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 True => 2 False => 1 0 => 0 null_!EQ => 0 null_lt => 0 ---------------------------------------- (18) Obligation: Complexity RNTS consisting of the following rules: !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' = 1 + y, y >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: x >= 0, z = 1 + x, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 !EQ(z, z') -{ 0 }-> !EQ(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x'', y'), 1 + y', 1 + (1 + x'') + xs, xs') :|: z'' = xs', xs >= 0, xs' >= 0, z = 1 + y', y' >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + y'', 1 + 0 + xs, xs') :|: z'' = xs', xs >= 0, z = 1 + y'', z' = 1 + 0 + xs, xs' >= 0, y'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, xs') :|: z'' = xs', xs >= 0, z' = 1 + x + xs, x >= 0, xs' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, min, 1 + x + xs, xs') :|: z'' = xs', xs >= 0, z' = 1 + x + xs, x >= 0, xs' >= 0, z = min, min >= 0 appmin(z, z', z'') -{ 2 }-> 1 + min + minsort(remove[Ite](!EQ(min, x1), min, 1 + x1 + xs'')) :|: x1 >= 0, xs'' >= 0, z = min, z'' = 1 + x1 + xs'', min >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + min + minsort(0) :|: xs >= 0, z'' = xs, z = min, min >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(min, xs, xs') :|: xs >= 0, z' = min, z = 1, x >= 0, xs' >= 0, z'' = 1 + x + xs, min >= 0, z1 = xs' appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, xs') :|: z = 2, xs >= 0, z' = min, x >= 0, xs' >= 0, z'' = 1 + x + xs, min >= 0, z1 = xs' appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0 lt(z, z') -{ 0 }-> lt(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x lt(z, z') -{ 0 }-> 2 :|: z' = 1 + y, y >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: x >= 0, z = x, z' = 0 lt(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + xs) :|: xs >= 0, z' = 1 + 0 + xs, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + x3, 1 + 0 + xs) :|: xs >= 0, z' = 1 + 0 + xs, z = 1 + x3, x3 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, x', 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, x >= 0, z = x' remove(z, z') -{ 1 }-> remove[Ite](!EQ(x2, y1), 1 + x2, 1 + (1 + y1) + xs) :|: y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z = 1 + x2, x2 >= 0 remove(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, z' = x', xs >= 0, x' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(x', xs) :|: z' = x', xs >= 0, z = 1, x' >= 0, x >= 0, z'' = 1 + x + xs ---------------------------------------- (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: !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x'', z - 1), 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](!EQ(z, x1), z, 1 + x1 + xs'')) :|: x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite](!EQ(z - 1, y1), 1 + (z - 1), 1 + (1 + y1) + xs) :|: y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs ---------------------------------------- (21) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID)) Found the following analysis order by SCC decomposition: { notEmpty } { !EQ } { lt } { remove[Ite], remove } { appmin, minsort, appmin[Ite][True][Ite] } ---------------------------------------- (22) Obligation: Complexity RNTS consisting of the following rules: !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x'', z - 1), 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](!EQ(z, x1), z, 1 + x1 + xs'')) :|: x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite](!EQ(z - 1, y1), 1 + (z - 1), 1 + (1 + y1) + xs) :|: y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {notEmpty}, {!EQ}, {lt}, {remove[Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]} ---------------------------------------- (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: !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x'', z - 1), 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](!EQ(z, x1), z, 1 + x1 + xs'')) :|: x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite](!EQ(z - 1, y1), 1 + (z - 1), 1 + (1 + y1) + xs) :|: y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {notEmpty}, {!EQ}, {lt}, {remove[Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]} ---------------------------------------- (25) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: notEmpty after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 2 ---------------------------------------- (26) Obligation: Complexity RNTS consisting of the following rules: !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x'', z - 1), 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](!EQ(z, x1), z, 1 + x1 + xs'')) :|: x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite](!EQ(z - 1, y1), 1 + (z - 1), 1 + (1 + y1) + xs) :|: y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {notEmpty}, {!EQ}, {lt}, {remove[Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: ?, size: O(1) [2] ---------------------------------------- (27) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: notEmpty after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 1 ---------------------------------------- (28) Obligation: Complexity RNTS consisting of the following rules: !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x'', z - 1), 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](!EQ(z, x1), z, 1 + x1 + xs'')) :|: x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite](!EQ(z - 1, y1), 1 + (z - 1), 1 + (1 + y1) + xs) :|: y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {!EQ}, {lt}, {remove[Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] ---------------------------------------- (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: !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x'', z - 1), 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](!EQ(z, x1), z, 1 + x1 + xs'')) :|: x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite](!EQ(z - 1, y1), 1 + (z - 1), 1 + (1 + y1) + xs) :|: y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {!EQ}, {lt}, {remove[Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] ---------------------------------------- (31) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: !EQ after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 2 ---------------------------------------- (32) Obligation: Complexity RNTS consisting of the following rules: !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x'', z - 1), 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](!EQ(z, x1), z, 1 + x1 + xs'')) :|: x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite](!EQ(z - 1, y1), 1 + (z - 1), 1 + (1 + y1) + xs) :|: y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {!EQ}, {lt}, {remove[Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] !EQ: runtime: ?, size: O(1) [2] ---------------------------------------- (33) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: !EQ after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 0 ---------------------------------------- (34) Obligation: Complexity RNTS consisting of the following rules: !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x'', z - 1), 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](!EQ(z, x1), z, 1 + x1 + xs'')) :|: x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite](!EQ(z - 1, y1), 1 + (z - 1), 1 + (1 + y1) + xs) :|: y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {lt}, {remove[Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] !EQ: runtime: O(1) [0], size: O(1) [2] ---------------------------------------- (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: !EQ(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 2, z - 1 >= 0, z' - 1 >= 0 !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x'', z - 1), 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](s, z, 1 + x1 + xs'')) :|: s >= 0, s <= 2, x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](s', 1 + (z - 1), 1 + (1 + y1) + xs) :|: s' >= 0, s' <= 2, y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {lt}, {remove[Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] !EQ: runtime: O(1) [0], size: O(1) [2] ---------------------------------------- (37) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: lt after applying outer abstraction to obtain an ITS, resulting in: O(1) with polynomial bound: 2 ---------------------------------------- (38) Obligation: Complexity RNTS consisting of the following rules: !EQ(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 2, z - 1 >= 0, z' - 1 >= 0 !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x'', z - 1), 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](s, z, 1 + x1 + xs'')) :|: s >= 0, s <= 2, x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](s', 1 + (z - 1), 1 + (1 + y1) + xs) :|: s' >= 0, s' <= 2, y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {lt}, {remove[Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] !EQ: runtime: O(1) [0], size: O(1) [2] lt: runtime: ?, size: O(1) [2] ---------------------------------------- (39) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: lt 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: !EQ(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 2, z - 1 >= 0, z' - 1 >= 0 !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x'', z - 1), 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](s, z, 1 + x1 + xs'')) :|: s >= 0, s <= 2, x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> lt(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](s', 1 + (z - 1), 1 + (1 + y1) + xs) :|: s' >= 0, s' <= 2, y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {remove[Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] !EQ: runtime: O(1) [0], size: O(1) [2] lt: 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: !EQ(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 2, z - 1 >= 0, z' - 1 >= 0 !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](s1, 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: s1 >= 0, s1 <= 2, xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](s, z, 1 + x1 + xs'')) :|: s >= 0, s <= 2, x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](s', 1 + (z - 1), 1 + (1 + y1) + xs) :|: s' >= 0, s' <= 2, y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {remove[Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] !EQ: runtime: O(1) [0], size: O(1) [2] lt: runtime: O(1) [0], size: O(1) [2] ---------------------------------------- (43) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using KoAT for: remove[Ite] after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z'' Computed SIZE bound using CoFloCo for: remove after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: z' ---------------------------------------- (44) Obligation: Complexity RNTS consisting of the following rules: !EQ(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 2, z - 1 >= 0, z' - 1 >= 0 !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](s1, 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: s1 >= 0, s1 <= 2, xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](s, z, 1 + x1 + xs'')) :|: s >= 0, s <= 2, x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](s', 1 + (z - 1), 1 + (1 + y1) + xs) :|: s' >= 0, s' <= 2, y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {remove[Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] !EQ: runtime: O(1) [0], size: O(1) [2] lt: runtime: O(1) [0], size: O(1) [2] remove[Ite]: runtime: ?, size: O(n^1) [z''] remove: runtime: ?, size: O(n^1) [z'] ---------------------------------------- (45) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: remove[Ite] after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 3 + z'' Computed RUNTIME bound using CoFloCo for: remove after applying outer abstraction to obtain an ITS, resulting in: O(n^1) with polynomial bound: 4 + z' ---------------------------------------- (46) Obligation: Complexity RNTS consisting of the following rules: !EQ(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 2, z - 1 >= 0, z' - 1 >= 0 !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](s1, 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: s1 >= 0, s1 <= 2, xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 2 }-> 1 + z + minsort(remove[Ite](s, z, 1 + x1 + xs'')) :|: s >= 0, s <= 2, x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 1 }-> remove[Ite](s', 1 + (z - 1), 1 + (1 + y1) + xs) :|: s' >= 0, s' <= 2, y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 0, 1 + (1 + y2) + xs) :|: xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(z', xs) :|: xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] !EQ: runtime: O(1) [0], size: O(1) [2] lt: runtime: O(1) [0], size: O(1) [2] remove[Ite]: runtime: O(n^1) [3 + z''], size: O(n^1) [z''] remove: runtime: O(n^1) [4 + z'], size: O(n^1) [z'] ---------------------------------------- (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: !EQ(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 2, z - 1 >= 0, z' - 1 >= 0 !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](s1, 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: s1 >= 0, s1 <= 2, xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 6 + x1 + xs'' }-> 1 + z + minsort(s3) :|: s3 >= 0, s3 <= 1 + x1 + xs'', s >= 0, s <= 2, x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 6 + xs + y1 }-> s4 :|: s4 >= 0, s4 <= 1 + (1 + y1) + xs, s' >= 0, s' <= 2, y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 6 + xs + y2 }-> s5 :|: s5 >= 0, s5 <= 1 + (1 + y2) + xs, xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 4 + z' }-> s6 :|: s6 >= 0, s6 <= 1 + 0 + (z' - 1), z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 4 + z' }-> s7 :|: s7 >= 0, s7 <= 1 + 0 + (z' - 1), z' - 1 >= 0, z = 0 remove(z, z') -{ 5 + x + xs }-> s8 :|: s8 >= 0, s8 <= 1 + x + xs, xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 4 + xs }-> 1 + x + s9 :|: s9 >= 0, s9 <= xs, xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] !EQ: runtime: O(1) [0], size: O(1) [2] lt: runtime: O(1) [0], size: O(1) [2] remove[Ite]: runtime: O(n^1) [3 + z''], size: O(n^1) [z''] remove: runtime: O(n^1) [4 + z'], size: O(n^1) [z'] ---------------------------------------- (49) IntTrsBoundProof (UPPER BOUND(ID)) Computed SIZE bound using CoFloCo for: appmin after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? Computed SIZE bound using CoFloCo for: minsort after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? Computed SIZE bound using CoFloCo for: appmin[Ite][True][Ite] after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (50) Obligation: Complexity RNTS consisting of the following rules: !EQ(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 2, z - 1 >= 0, z' - 1 >= 0 !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](s1, 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: s1 >= 0, s1 <= 2, xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 6 + x1 + xs'' }-> 1 + z + minsort(s3) :|: s3 >= 0, s3 <= 1 + x1 + xs'', s >= 0, s <= 2, x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 6 + xs + y1 }-> s4 :|: s4 >= 0, s4 <= 1 + (1 + y1) + xs, s' >= 0, s' <= 2, y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 6 + xs + y2 }-> s5 :|: s5 >= 0, s5 <= 1 + (1 + y2) + xs, xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 4 + z' }-> s6 :|: s6 >= 0, s6 <= 1 + 0 + (z' - 1), z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 4 + z' }-> s7 :|: s7 >= 0, s7 <= 1 + 0 + (z' - 1), z' - 1 >= 0, z = 0 remove(z, z') -{ 5 + x + xs }-> s8 :|: s8 >= 0, s8 <= 1 + x + xs, xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 4 + xs }-> 1 + x + s9 :|: s9 >= 0, s9 <= xs, xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] !EQ: runtime: O(1) [0], size: O(1) [2] lt: runtime: O(1) [0], size: O(1) [2] remove[Ite]: runtime: O(n^1) [3 + z''], size: O(n^1) [z''] remove: runtime: O(n^1) [4 + z'], size: O(n^1) [z'] appmin: runtime: ?, size: INF minsort: runtime: ?, size: INF appmin[Ite][True][Ite]: runtime: ?, size: INF ---------------------------------------- (51) IntTrsBoundProof (UPPER BOUND(ID)) Computed RUNTIME bound using CoFloCo for: appmin after applying outer abstraction to obtain an ITS, resulting in: INF with polynomial bound: ? ---------------------------------------- (52) Obligation: Complexity RNTS consisting of the following rules: !EQ(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 2, z - 1 >= 0, z' - 1 >= 0 !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](s1, 1 + (z - 1), 1 + (1 + x'') + xs, z'') :|: s1 >= 0, s1 <= 2, xs >= 0, z'' >= 0, z - 1 >= 0, z' = 1 + (1 + x'') + xs, x'' >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + (z - 1), 1 + 0 + (z' - 1), z'') :|: z' - 1 >= 0, z'' >= 0, z - 1 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](1, 0, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z = 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](0, z, 1 + x + xs, z'') :|: xs >= 0, z' = 1 + x + xs, x >= 0, z'' >= 0, z >= 0 appmin(z, z', z'') -{ 6 + x1 + xs'' }-> 1 + z + minsort(s3) :|: s3 >= 0, s3 <= 1 + x1 + xs'', s >= 0, s <= 2, x1 >= 0, xs'' >= 0, z'' = 1 + x1 + xs'', z >= 0, z' = 0 appmin(z, z', z'') -{ 1 }-> 1 + z + minsort(0) :|: z'' >= 0, z >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, z1) :|: z = 2, xs >= 0, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(z', xs, z1) :|: xs >= 0, z = 1, x >= 0, z1 >= 0, z'' = 1 + x + xs, z' >= 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0 lt(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 2, z - 1 >= 0, z' - 1 >= 0 lt(z, z') -{ 0 }-> 2 :|: z' - 1 >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0 lt(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 remove(z, z') -{ 6 + xs + y1 }-> s4 :|: s4 >= 0, s4 <= 1 + (1 + y1) + xs, s' >= 0, s' <= 2, y1 >= 0, xs >= 0, z' = 1 + (1 + y1) + xs, z - 1 >= 0 remove(z, z') -{ 6 + xs + y2 }-> s5 :|: s5 >= 0, s5 <= 1 + (1 + y2) + xs, xs >= 0, z' = 1 + (1 + y2) + xs, y2 >= 0, z = 0 remove(z, z') -{ 4 + z' }-> s6 :|: s6 >= 0, s6 <= 1 + 0 + (z' - 1), z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 4 + z' }-> s7 :|: s7 >= 0, s7 <= 1 + 0 + (z' - 1), z' - 1 >= 0, z = 0 remove(z, z') -{ 5 + x + xs }-> s8 :|: s8 >= 0, s8 <= 1 + x + xs, xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite](z, z', z'') -{ 4 + xs }-> 1 + x + s9 :|: s9 >= 0, s9 <= xs, xs >= 0, z = 1, z' >= 0, x >= 0, z'' = 1 + x + xs Function symbols to be analyzed: {appmin,minsort,appmin[Ite][True][Ite]} Previous analysis results are: notEmpty: runtime: O(1) [1], size: O(1) [2] !EQ: runtime: O(1) [0], size: O(1) [2] lt: runtime: O(1) [0], size: O(1) [2] remove[Ite]: runtime: O(n^1) [3 + z''], size: O(n^1) [z''] remove: runtime: O(n^1) [4 + z'], size: O(n^1) [z'] appmin: runtime: INF, size: INF minsort: runtime: ?, size: INF appmin[Ite][True][Ite]: runtime: ?, size: INF ---------------------------------------- (53) CompletionProof (UPPER BOUND(ID)) The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added: !EQ(v0, v1) -> null_!EQ [0] lt(v0, v1) -> null_lt [0] remove[Ite](v0, v1, v2) -> null_remove[Ite] [0] appmin[Ite][True][Ite](v0, v1, v2, v3) -> null_appmin[Ite][True][Ite] [0] minsort(v0) -> null_minsort [0] appmin(v0, v1, v2) -> null_appmin [0] notEmpty(v0) -> null_notEmpty [0] remove(v0, v1) -> null_remove [0] And the following fresh constants: null_!EQ, null_lt, null_remove[Ite], null_appmin[Ite][True][Ite], null_minsort, null_appmin, null_notEmpty, null_remove ---------------------------------------- (54) 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: minsort(Cons(x, xs)) -> appmin(x, xs, Cons(x, xs)) [1] minsort(Nil) -> Nil [1] appmin(min, Cons(x, xs), xs') -> appmin[Ite][True][Ite](lt(x, min), min, Cons(x, xs), xs') [1] appmin(min, Nil, xs) -> Cons(min, minsort(remove(min, xs))) [1] notEmpty(Cons(x, xs)) -> True [1] notEmpty(Nil) -> False [1] remove(x', Cons(x, xs)) -> remove[Ite](!EQ(x', x), x', Cons(x, xs)) [1] !EQ(S(x), S(y)) -> !EQ(x, y) [0] !EQ(0, S(y)) -> False [0] !EQ(S(x), 0) -> False [0] !EQ(0, 0) -> True [0] lt(S(x), S(y)) -> lt(x, y) [0] lt(0, S(y)) -> True [0] lt(x, 0) -> False [0] remove[Ite](False, x', Cons(x, xs)) -> Cons(x, remove(x', xs)) [0] appmin[Ite][True][Ite](True, min, Cons(x, xs), xs') -> appmin(x, xs, xs') [0] remove[Ite](True, x', Cons(x, xs)) -> xs [0] appmin[Ite][True][Ite](False, min, Cons(x, xs), xs') -> appmin(min, xs, xs') [0] !EQ(v0, v1) -> null_!EQ [0] lt(v0, v1) -> null_lt [0] remove[Ite](v0, v1, v2) -> null_remove[Ite] [0] appmin[Ite][True][Ite](v0, v1, v2, v3) -> null_appmin[Ite][True][Ite] [0] minsort(v0) -> null_minsort [0] appmin(v0, v1, v2) -> null_appmin [0] notEmpty(v0) -> null_notEmpty [0] remove(v0, v1) -> null_remove [0] The TRS has the following type information: minsort :: Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove Cons :: S:0 -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove appmin :: S:0 -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove Nil :: Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove appmin[Ite][True][Ite] :: True:False:null_!EQ:null_lt:null_notEmpty -> S:0 -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove lt :: S:0 -> S:0 -> True:False:null_!EQ:null_lt:null_notEmpty remove :: S:0 -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove notEmpty :: Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove -> True:False:null_!EQ:null_lt:null_notEmpty True :: True:False:null_!EQ:null_lt:null_notEmpty False :: True:False:null_!EQ:null_lt:null_notEmpty remove[Ite] :: True:False:null_!EQ:null_lt:null_notEmpty -> S:0 -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove -> Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove !EQ :: S:0 -> S:0 -> True:False:null_!EQ:null_lt:null_notEmpty S :: S:0 -> S:0 0 :: S:0 null_!EQ :: True:False:null_!EQ:null_lt:null_notEmpty null_lt :: True:False:null_!EQ:null_lt:null_notEmpty null_remove[Ite] :: Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove null_appmin[Ite][True][Ite] :: Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove null_minsort :: Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove null_appmin :: Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove null_notEmpty :: True:False:null_!EQ:null_lt:null_notEmpty null_remove :: Cons:Nil:null_remove[Ite]:null_appmin[Ite][True][Ite]:null_minsort:null_appmin:null_remove Rewrite Strategy: INNERMOST ---------------------------------------- (55) 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 True => 2 False => 1 0 => 0 null_!EQ => 0 null_lt => 0 null_remove[Ite] => 0 null_appmin[Ite][True][Ite] => 0 null_minsort => 0 null_appmin => 0 null_notEmpty => 0 null_remove => 0 ---------------------------------------- (56) Obligation: Complexity RNTS consisting of the following rules: !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0 !EQ(z, z') -{ 0 }-> 1 :|: z' = 1 + y, y >= 0, z = 0 !EQ(z, z') -{ 0 }-> 1 :|: x >= 0, z = 1 + x, z' = 0 !EQ(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 !EQ(z, z') -{ 0 }-> !EQ(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](lt(x, min), min, 1 + x + xs, xs') :|: z'' = xs', xs >= 0, z' = 1 + x + xs, x >= 0, xs' >= 0, z = min, min >= 0 appmin(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 appmin(z, z', z'') -{ 1 }-> 1 + min + minsort(remove(min, xs)) :|: xs >= 0, z'' = xs, z = min, min >= 0, z' = 0 appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(min, xs, xs') :|: xs >= 0, z' = min, z = 1, x >= 0, xs' >= 0, z'' = 1 + x + xs, min >= 0, z1 = xs' appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> appmin(x, xs, xs') :|: z = 2, xs >= 0, z' = min, x >= 0, xs' >= 0, z'' = 1 + x + xs, min >= 0, z1 = xs' appmin[Ite][True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0 lt(z, z') -{ 0 }-> lt(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x lt(z, z') -{ 0 }-> 2 :|: z' = 1 + y, y >= 0, z = 0 lt(z, z') -{ 0 }-> 1 :|: x >= 0, z = x, z' = 0 lt(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 minsort(z) -{ 1 }-> appmin(x, xs, 1 + x + xs) :|: z = 1 + x + xs, xs >= 0, x >= 0 minsort(z) -{ 1 }-> 0 :|: z = 0 minsort(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 notEmpty(z) -{ 1 }-> 2 :|: z = 1 + x + xs, xs >= 0, x >= 0 notEmpty(z) -{ 1 }-> 1 :|: z = 0 notEmpty(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0 remove(z, z') -{ 1 }-> remove[Ite](!EQ(x', x), x', 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, x >= 0, z = x' remove(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 remove[Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, z' = x', xs >= 0, x' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 remove[Ite](z, z', z'') -{ 0 }-> 1 + x + remove(x', xs) :|: z' = x', xs >= 0, z = 1, x' >= 0, x >= 0, z'' = 1 + x + xs Only complete derivations are relevant for the runtime complexity. ---------------------------------------- (57) CpxTrsToCdtProof (UPPER BOUND(ID)) Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT ---------------------------------------- (58) Obligation: Complexity Dependency Tuples Problem Rules: !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 appmin[Ite][True][Ite](True, z0, Cons(z1, z2), z3) -> appmin(z1, z2, z3) appmin[Ite][True][Ite](False, z0, Cons(z1, z2), z3) -> appmin(z0, z2, z3) minsort(Cons(z0, z1)) -> appmin(z0, z1, Cons(z0, z1)) minsort(Nil) -> Nil appmin(z0, Cons(z1, z2), z3) -> appmin[Ite][True][Ite](<(z1, z0), z0, Cons(z1, z2), z3) appmin(z0, Nil, z1) -> Cons(z0, minsort(remove(z0, z1))) notEmpty(Cons(z0, z1)) -> True notEmpty(Nil) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) !EQ'(0, S(z0)) -> c1 !EQ'(S(z0), 0) -> c2 !EQ'(0, 0) -> c3 <'(S(z0), S(z1)) -> c4(<'(z0, z1)) <'(0, S(z0)) -> c5 <'(z0, 0) -> c6 REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) REMOVE[ITE](True, z0, Cons(z1, z2)) -> c8 APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) MINSORT(Nil) -> c12 APPMIN(z0, Cons(z1, z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c14(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) NOTEMPTY(Cons(z0, z1)) -> c15 NOTEMPTY(Nil) -> c16 REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) MINSORT(Nil) -> c12 APPMIN(z0, Cons(z1, z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c14(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) NOTEMPTY(Cons(z0, z1)) -> c15 NOTEMPTY(Nil) -> c16 REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) K tuples:none Defined Rule Symbols: minsort_1, appmin_3, notEmpty_1, remove_2, !EQ_2, <_2, remove[Ite]_3, appmin[Ite][True][Ite]_4 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, NOTEMPTY_1, REMOVE_2 Compound Symbols: c_1, c1, c2, c3, c4_1, c5, c6, c7_1, c8, c9_1, c10_1, c11_1, c12, c13_2, c14_2, c15, c16, c17_2 ---------------------------------------- (59) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 9 trailing nodes: <'(0, S(z0)) -> c5 NOTEMPTY(Nil) -> c16 NOTEMPTY(Cons(z0, z1)) -> c15 !EQ'(S(z0), 0) -> c2 MINSORT(Nil) -> c12 !EQ'(0, S(z0)) -> c1 <'(z0, 0) -> c6 REMOVE[ITE](True, z0, Cons(z1, z2)) -> c8 !EQ'(0, 0) -> c3 ---------------------------------------- (60) Obligation: Complexity Dependency Tuples Problem Rules: !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 appmin[Ite][True][Ite](True, z0, Cons(z1, z2), z3) -> appmin(z1, z2, z3) appmin[Ite][True][Ite](False, z0, Cons(z1, z2), z3) -> appmin(z0, z2, z3) minsort(Cons(z0, z1)) -> appmin(z0, z1, Cons(z0, z1)) minsort(Nil) -> Nil appmin(z0, Cons(z1, z2), z3) -> appmin[Ite][True][Ite](<(z1, z0), z0, Cons(z1, z2), z3) appmin(z0, Nil, z1) -> Cons(z0, minsort(remove(z0, z1))) notEmpty(Cons(z0, z1)) -> True notEmpty(Nil) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Cons(z1, z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c14(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Cons(z1, z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c14(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) K tuples:none Defined Rule Symbols: minsort_1, appmin_3, notEmpty_1, remove_2, !EQ_2, <_2, remove[Ite]_3, appmin[Ite][True][Ite]_4 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_2, c14_2, c17_2 ---------------------------------------- (61) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: appmin[Ite][True][Ite](True, z0, Cons(z1, z2), z3) -> appmin(z1, z2, z3) appmin[Ite][True][Ite](False, z0, Cons(z1, z2), z3) -> appmin(z0, z2, z3) minsort(Cons(z0, z1)) -> appmin(z0, z1, Cons(z0, z1)) minsort(Nil) -> Nil appmin(z0, Cons(z1, z2), z3) -> appmin[Ite][True][Ite](<(z1, z0), z0, Cons(z1, z2), z3) appmin(z0, Nil, z1) -> Cons(z0, minsort(remove(z0, z1))) notEmpty(Cons(z0, z1)) -> True notEmpty(Nil) -> False ---------------------------------------- (62) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Cons(z1, z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c14(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Cons(z1, z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c14(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) K tuples:none Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_2, c14_2, c17_2 ---------------------------------------- (63) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace APPMIN(z0, Cons(z1, z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) by APPMIN(S(z1), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3), <'(0, S(z0))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3), <'(z0, 0)) ---------------------------------------- (64) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Nil, z1) -> c14(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) APPMIN(S(z1), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3), <'(0, S(z0))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3), <'(z0, 0)) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Nil, z1) -> c14(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) APPMIN(S(z1), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3), <'(0, S(z0))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3), <'(z0, 0)) K tuples:none Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c14_2, c17_2, c13_2 ---------------------------------------- (65) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (66) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Nil, z1) -> c14(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) APPMIN(S(z1), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Nil, z1) -> c14(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) APPMIN(S(z1), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) K tuples:none Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c14_2, c17_2, c13_2, c13_1 ---------------------------------------- (67) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace APPMIN(z0, Nil, z1) -> c14(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) by APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) ---------------------------------------- (68) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) APPMIN(S(z1), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) APPMIN(S(z1), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) K tuples:none Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE_2, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c17_2, c13_2, c13_1, c14_2 ---------------------------------------- (69) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace REMOVE(z0, Cons(z1, z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) by REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2)), !EQ'(0, S(z0))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2)), !EQ'(S(z0), 0)) REMOVE(0, Cons(0, x2)) -> c17(REMOVE[ITE](True, 0, Cons(0, x2)), !EQ'(0, 0)) ---------------------------------------- (70) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z1), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2)), !EQ'(0, S(z0))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2)), !EQ'(S(z0), 0)) REMOVE(0, Cons(0, x2)) -> c17(REMOVE[ITE](True, 0, Cons(0, x2)), !EQ'(0, 0)) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z1), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2)), !EQ'(0, S(z0))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2)), !EQ'(S(z0), 0)) REMOVE(0, Cons(0, x2)) -> c17(REMOVE[ITE](True, 0, Cons(0, x2)), !EQ'(0, 0)) K tuples:none Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_2, c13_1, c14_2, c17_2 ---------------------------------------- (71) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 4 trailing tuple parts ---------------------------------------- (72) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z1), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z1), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 K tuples:none Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_2, c13_1, c14_2, c17_2, c17_1, c17 ---------------------------------------- (73) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace APPMIN(S(z1), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) by APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) ---------------------------------------- (74) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) K tuples:none Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_1, c14_2, c17_2, c17_1, c17, c13_2 ---------------------------------------- (75) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) We considered the (Usable) Rules: <(z0, 0) -> False <(0, S(z0)) -> True <(S(z0), S(z1)) -> <(z0, z1) And the Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) The order we found is given by the following interpretation: Polynomial interpretation : POL(!EQ(x_1, x_2)) = x_1 POL(!EQ'(x_1, x_2)) = 0 POL(0) = 0 POL(<(x_1, x_2)) = [1] POL(<'(x_1, x_2)) = 0 POL(APPMIN(x_1, x_2, x_3)) = [1] + x_3 POL(APPMIN[ITE][TRUE][ITE](x_1, x_2, x_3, x_4)) = x_1 + x_4 POL(Cons(x_1, x_2)) = 0 POL(False) = [1] POL(MINSORT(x_1)) = [1] POL(Nil) = [1] POL(REMOVE(x_1, x_2)) = 0 POL(REMOVE[ITE](x_1, x_2, x_3)) = 0 POL(S(x_1)) = 0 POL(True) = [1] POL(c(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c13(x_1, x_2)) = x_1 + x_2 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c17) = 0 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c4(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(remove(x_1, x_2)) = [1] + x_1 + x_2 POL(remove[Ite](x_1, x_2, x_3)) = [1] + x_2 + x_3 ---------------------------------------- (76) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_1, c14_2, c17_2, c17_1, c17, c13_2 ---------------------------------------- (77) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace APPMIN(z0, Nil, Cons(z1, z2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) by APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), x2)) -> c14(MINSORT(remove[Ite](False, 0, Cons(S(z0), x2))), REMOVE(0, Cons(S(z0), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) ---------------------------------------- (78) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), x2)) -> c14(MINSORT(remove[Ite](False, 0, Cons(S(z0), x2))), REMOVE(0, Cons(S(z0), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), x2)) -> c14(MINSORT(remove[Ite](False, 0, Cons(S(z0), x2))), REMOVE(0, Cons(S(z0), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_1, c17_2, c17_1, c17, c13_2, c14_2 ---------------------------------------- (79) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace REMOVE(S(z0), Cons(S(z1), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) by REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(0), Cons(S(0), x2)) -> c17(REMOVE[ITE](True, S(0), Cons(S(0), x2)), !EQ'(S(0), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) ---------------------------------------- (80) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), x2)) -> c14(MINSORT(remove[Ite](False, 0, Cons(S(z0), x2))), REMOVE(0, Cons(S(z0), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(0), Cons(S(0), x2)) -> c17(REMOVE[ITE](True, S(0), Cons(S(0), x2)), !EQ'(S(0), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), x2)) -> c14(MINSORT(remove[Ite](False, 0, Cons(S(z0), x2))), REMOVE(0, Cons(S(z0), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(0), Cons(S(0), x2)) -> c17(REMOVE[ITE](True, S(0), Cons(S(0), x2)), !EQ'(S(0), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2 ---------------------------------------- (81) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (82) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), x2)) -> c14(MINSORT(remove[Ite](False, 0, Cons(S(z0), x2))), REMOVE(0, Cons(S(z0), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), x2)) -> c14(MINSORT(remove[Ite](False, 0, Cons(S(z0), x2))), REMOVE(0, Cons(S(z0), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2 ---------------------------------------- (83) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace APPMIN(0, Nil, Cons(S(z0), x2)) -> c14(MINSORT(remove[Ite](False, 0, Cons(S(z0), x2))), REMOVE(0, Cons(S(z0), x2))) by APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) ---------------------------------------- (84) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2 ---------------------------------------- (85) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace APPMIN(S(z0), Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) by APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) ---------------------------------------- (86) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2 ---------------------------------------- (87) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace APPMIN(0, Nil, Cons(0, x2)) -> c14(MINSORT(remove[Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) by APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) ---------------------------------------- (88) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2 ---------------------------------------- (89) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) We considered the (Usable) Rules: remove[Ite](True, z0, Cons(z1, z2)) -> z2 remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) And the Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) The order we found is given by the following interpretation: Polynomial interpretation : POL(!EQ(x_1, x_2)) = x_1 + x_2 POL(!EQ'(x_1, x_2)) = 0 POL(0) = 0 POL(<(x_1, x_2)) = [1] + x_1 + x_2 POL(<'(x_1, x_2)) = 0 POL(APPMIN(x_1, x_2, x_3)) = x_3 POL(APPMIN[ITE][TRUE][ITE](x_1, x_2, x_3, x_4)) = x_4 POL(Cons(x_1, x_2)) = [1] + x_2 POL(False) = 0 POL(MINSORT(x_1)) = x_1 POL(Nil) = [1] POL(REMOVE(x_1, x_2)) = 0 POL(REMOVE[ITE](x_1, x_2, x_3)) = 0 POL(S(x_1)) = 0 POL(True) = [1] POL(c(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11(x_1)) = x_1 POL(c13(x_1)) = x_1 POL(c13(x_1, x_2)) = x_1 + x_2 POL(c14(x_1, x_2)) = x_1 + x_2 POL(c17) = 0 POL(c17(x_1)) = x_1 POL(c17(x_1, x_2)) = x_1 + x_2 POL(c4(x_1)) = x_1 POL(c7(x_1)) = x_1 POL(c9(x_1)) = x_1 POL(remove(x_1, x_2)) = x_2 POL(remove[Ite](x_1, x_2, x_3)) = x_3 ---------------------------------------- (90) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE]_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2 ---------------------------------------- (91) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace REMOVE[ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) by REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) ---------------------------------------- (92) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: !EQ'_2, <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3 Compound Symbols: c_1, c4_1, c9_1, c10_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2, c7_1 ---------------------------------------- (93) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) by !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) ---------------------------------------- (94) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: <'(S(z0), S(z1)) -> c4(<'(z0, z1)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c17(!EQ'(S(0), S(0))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c4_1, c9_1, c10_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2, c7_1, c_1 ---------------------------------------- (95) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 3 trailing tuple parts ---------------------------------------- (96) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: <'(S(z0), S(z1)) -> c4(<'(z0, z1)) APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c4_1, c9_1, c10_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2, c7_1, c_1 ---------------------------------------- (97) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace APPMIN[ITE][TRUE][ITE](True, z0, Cons(z1, z2), z3) -> c9(APPMIN(z1, z2, z3)) by APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) ---------------------------------------- (98) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: <'(S(z0), S(z1)) -> c4(<'(z0, z1)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c4_1, c10_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2, c7_1, c_1, c9_1 ---------------------------------------- (99) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) by APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) ---------------------------------------- (100) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: <'(S(z0), S(z1)) -> c4(<'(z0, z1)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: <'_2, MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4 Compound Symbols: c4_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2, c7_1, c_1, c9_1, c10_1 ---------------------------------------- (101) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace APPMIN(S(z0), Cons(0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) by APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) ---------------------------------------- (102) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: <'(S(z0), S(z1)) -> c4(<'(z0, z1)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: <'_2, MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4 Compound Symbols: c4_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2, c7_1, c_1, c9_1, c10_1 ---------------------------------------- (103) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace APPMIN(S(x0), Cons(S(x1), x2), x3) -> c13(<'(S(x1), S(x0))) by APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) APPMIN(S(0), Cons(S(z1), z2), x2) -> c13(<'(S(z1), S(0))) ---------------------------------------- (104) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: <'(S(z0), S(z1)) -> c4(<'(z0, z1)) MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) APPMIN(S(0), Cons(S(z1), z2), x2) -> c13(<'(S(z1), S(0))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) APPMIN(S(0), Cons(S(z1), z2), x2) -> c13(<'(S(z1), S(0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: <'_2, MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4 Compound Symbols: c4_1, c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2, c7_1, c_1, c9_1, c10_1 ---------------------------------------- (105) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace <'(S(z0), S(z1)) -> c4(<'(z0, z1)) by <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) ---------------------------------------- (106) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) APPMIN(S(0), Cons(S(z1), z2), x2) -> c13(<'(S(z1), S(0))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) APPMIN(S(0), Cons(S(z1), z2), x2) -> c13(<'(S(z1), S(0))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2 Compound Symbols: c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2, c7_1, c_1, c9_1, c10_1, c4_1 ---------------------------------------- (107) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: APPMIN(S(0), Cons(S(z1), z2), x2) -> c13(<'(S(z1), S(0))) ---------------------------------------- (108) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3), <'(S(0), S(S(z0)))) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2 Compound Symbols: c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2, c7_1, c_1, c9_1, c10_1, c4_1 ---------------------------------------- (109) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (110) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2 Compound Symbols: c11_1, c13_1, c17_1, c17, c13_2, c14_2, c17_2, c7_1, c_1, c9_1, c10_1, c4_1 ---------------------------------------- (111) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c14(MINSORT(remove[Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) by APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) ---------------------------------------- (112) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2 Compound Symbols: c11_1, c13_1, c17_1, c17, c13_2, c17_2, c14_2, c7_1, c_1, c9_1, c10_1, c4_1 ---------------------------------------- (113) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace APPMIN(S(z0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) by APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) ---------------------------------------- (114) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2 Compound Symbols: c11_1, c13_1, c17_1, c17, c13_2, c17_2, c14_2, c7_1, c_1, c9_1, c10_1, c4_1 ---------------------------------------- (115) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) by APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) ---------------------------------------- (116) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) S tuples: MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: MINSORT_1, APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2 Compound Symbols: c11_1, c13_1, c17_1, c17, c13_2, c17_2, c14_2, c7_1, c_1, c9_1, c10_1, c4_1 ---------------------------------------- (117) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace MINSORT(Cons(z0, z1)) -> c11(APPMIN(z0, z1, Cons(z0, z1))) by MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) ---------------------------------------- (118) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1 Compound Symbols: c13_1, c17_1, c17, c13_2, c17_2, c14_2, c7_1, c_1, c9_1, c10_1, c4_1, c11_1 ---------------------------------------- (119) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE(S(x0), Cons(S(x1), x2)) -> c17(!EQ'(S(x0), S(x1))) by REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) ---------------------------------------- (120) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1 Compound Symbols: c13_1, c17_1, c17, c13_2, c17_2, c14_2, c7_1, c_1, c9_1, c10_1, c4_1, c11_1 ---------------------------------------- (121) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE[ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) by REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) ---------------------------------------- (122) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1 Compound Symbols: c13_1, c17_1, c17, c13_2, c17_2, c14_2, c7_1, c_1, c9_1, c10_1, c4_1, c11_1 ---------------------------------------- (123) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE(0, Cons(S(z0), x2)) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), x2))) by REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) ---------------------------------------- (124) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1 Compound Symbols: c13_1, c17_1, c17, c13_2, c17_2, c14_2, c7_1, c_1, c9_1, c10_1, c4_1, c11_1 ---------------------------------------- (125) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE[ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) by REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) ---------------------------------------- (126) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1 Compound Symbols: c13_1, c17_1, c17, c13_2, c17_2, c14_2, c7_1, c_1, c9_1, c10_1, c4_1, c11_1 ---------------------------------------- (127) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE(S(z0), Cons(0, x2)) -> c17(REMOVE[ITE](False, S(z0), Cons(0, x2))) by REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) ---------------------------------------- (128) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1 Compound Symbols: c13_1, c17, c13_2, c17_2, c14_2, c7_1, c_1, c17_1, c9_1, c10_1, c4_1, c11_1 ---------------------------------------- (129) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE[ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) by REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) ---------------------------------------- (130) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1 Compound Symbols: c13_1, c17, c13_2, c17_2, c14_2, c7_1, c_1, c17_1, c9_1, c10_1, c4_1, c11_1 ---------------------------------------- (131) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE[ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) by REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) ---------------------------------------- (132) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, REMOVE[ITE]_3, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1 Compound Symbols: c13_1, c17, c13_2, c17_2, c14_2, c7_1, c_1, c17_1, c9_1, c10_1, c4_1, c11_1 ---------------------------------------- (133) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE[ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) by REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) ---------------------------------------- (134) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, !EQ'_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1, REMOVE[ITE]_3 Compound Symbols: c13_1, c17, c13_2, c17_2, c14_2, c_1, c17_1, c9_1, c10_1, c4_1, c11_1, c7_1 ---------------------------------------- (135) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) by !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) ---------------------------------------- (136) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c13_1, c17, c13_2, c17_2, c14_2, c17_1, c9_1, c10_1, c4_1, c11_1, c7_1, c_1 ---------------------------------------- (137) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) by REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) ---------------------------------------- (138) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c13_1, c17, c13_2, c14_2, c17_1, c9_1, c10_1, c4_1, c11_1, c7_1, c_1, c17_2 ---------------------------------------- (139) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE(S(0), Cons(S(S(z0)), x2)) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), x2))) by REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) ---------------------------------------- (140) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c13_1, c17, c13_2, c14_2, c17_1, c9_1, c10_1, c4_1, c11_1, c7_1, c_1, c17_2 ---------------------------------------- (141) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE(S(S(z0)), Cons(S(0), x2)) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), x2))) by REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) ---------------------------------------- (142) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c13_1, c17, c13_2, c14_2, c9_1, c10_1, c4_1, c11_1, c17_1, c7_1, c_1, c17_2 ---------------------------------------- (143) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c9(APPMIN(S(S(x1)), x2, x3)) by APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) ---------------------------------------- (144) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c13_1, c17, c13_2, c14_2, c9_1, c10_1, c4_1, c11_1, c17_1, c7_1, c_1, c17_2 ---------------------------------------- (145) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(S(0), x1), x2) -> c9(APPMIN(S(0), x1, x2)) by APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) ---------------------------------------- (146) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c13_1, c17, c13_2, c14_2, c10_1, c4_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2 ---------------------------------------- (147) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN[ITE][TRUE][ITE](False, 0, Cons(x0, x1), x2) -> c10(APPMIN(0, x1, x2)) by APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) ---------------------------------------- (148) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) S tuples: APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: APPMIN_3, REMOVE_2, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c13_1, c17, c13_2, c14_2, c10_1, c4_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2 ---------------------------------------- (149) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(0, Cons(z0, x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) by APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) ---------------------------------------- (150) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) S tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c17, c13_2, c14_2, c10_1, c13_1, c4_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2 ---------------------------------------- (151) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2), x3) -> c10(APPMIN(S(S(x0)), x2, x3)) by APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(S(z0)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c10(APPMIN(S(S(z0)), Nil, Cons(0, y1))) ---------------------------------------- (152) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(S(z0)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c10(APPMIN(S(S(z0)), Nil, Cons(0, y1))) S tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c17, c13_2, c14_2, c10_1, c13_1, c4_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2 ---------------------------------------- (153) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c17(REMOVE[ITE](!EQ(S(y0), S(y1)), S(S(S(y0))), Cons(S(S(S(y1))), z2)), !EQ'(S(S(S(y0))), S(S(S(y1))))) by REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) ---------------------------------------- (154) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(S(z0)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c10(APPMIN(S(S(z0)), Nil, Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) S tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, <'_2, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c17, c13_2, c14_2, c10_1, c13_1, c4_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2 ---------------------------------------- (155) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(x0), x1), x2) -> c10(APPMIN(S(0), x1, x2)) by APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y0)), z2) -> c10(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y0), y1)), z2) -> c10(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y0), y1)) -> c10(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y0)) -> c10(APPMIN(S(0), Nil, Cons(0, y0))) ---------------------------------------- (156) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(S(z0)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c10(APPMIN(S(S(z0)), Nil, Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y0)), z2) -> c10(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y0), y1)), z2) -> c10(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y0), y1)) -> c10(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y0)) -> c10(APPMIN(S(0), Nil, Cons(0, y0))) S tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: REMOVE_2, APPMIN_3, <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c17, c13_2, c14_2, c13_1, c4_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2, c10_1 ---------------------------------------- (157) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c13(<'(S(z1), S(z0))) by APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) ---------------------------------------- (158) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(S(z0)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c10(APPMIN(S(S(z0)), Nil, Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y0)), z2) -> c10(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y0), y1)), z2) -> c10(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y0), y1)) -> c10(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y0)) -> c10(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) S tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: REMOVE_2, APPMIN_3, <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c17, c13_2, c14_2, c13_1, c4_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2, c10_1 ---------------------------------------- (159) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c13(<'(S(z1), S(S(x1)))) by APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) ---------------------------------------- (160) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(S(z0)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c10(APPMIN(S(S(z0)), Nil, Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y0)), z2) -> c10(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y0), y1)), z2) -> c10(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y0), y1)) -> c10(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y0)) -> c10(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) S tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: REMOVE_2, APPMIN_3, <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE]_3, !EQ'_2 Compound Symbols: c17, c13_2, c14_2, c13_1, c4_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2, c10_1 ---------------------------------------- (161) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) by <'(S(S(S(y0))), S(S(S(y1)))) -> c4(<'(S(S(y0)), S(S(y1)))) ---------------------------------------- (162) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(S(z0)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c10(APPMIN(S(S(z0)), Nil, Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y0)), z2) -> c10(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y0), y1)), z2) -> c10(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y0), y1)) -> c10(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y0)) -> c10(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) <'(S(S(S(y0))), S(S(S(y1)))) -> c4(<'(S(S(y0)), S(S(y1)))) S tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE]_3, !EQ'_2, <'_2 Compound Symbols: c17, c13_2, c14_2, c13_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2, c10_1, c4_1 ---------------------------------------- (163) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(S(z1)), Cons(S(S(z0)), x2), x3), <'(S(S(z0)), S(S(z1)))) by APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(S(y1))), Cons(S(S(S(y0))), z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(S(y0), S(y1)), S(S(S(y1))), Cons(S(S(S(y0))), z2), z3), <'(S(S(S(y0))), S(S(S(y1))))) ---------------------------------------- (164) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(S(z0)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c10(APPMIN(S(S(z0)), Nil, Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y0)), z2) -> c10(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y0), y1)), z2) -> c10(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y0), y1)) -> c10(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y0)) -> c10(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) <'(S(S(S(y0))), S(S(S(y1)))) -> c4(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(S(y1))), Cons(S(S(S(y0))), z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(S(y0), S(y1)), S(S(S(y1))), Cons(S(S(S(y0))), z2), z3), <'(S(S(S(y0))), S(S(S(y1))))) S tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(S(y1))), Cons(S(S(S(y0))), z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(S(y0), S(y1)), S(S(S(y1))), Cons(S(S(S(y0))), z2), z3), <'(S(S(S(y0))), S(S(S(y1))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE]_3, !EQ'_2, <'_2 Compound Symbols: c17, c14_2, c13_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2, c10_1, c4_1, c13_2 ---------------------------------------- (165) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) by APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y1))) ---------------------------------------- (166) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(S(z0)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c10(APPMIN(S(S(z0)), Nil, Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y0)), z2) -> c10(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y0), y1)), z2) -> c10(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y0), y1)) -> c10(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y0)) -> c10(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) <'(S(S(S(y0))), S(S(S(y1)))) -> c4(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(S(y1))), Cons(S(S(S(y0))), z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(S(y0), S(y1)), S(S(S(y1))), Cons(S(S(S(y0))), z2), z3), <'(S(S(S(y0))), S(S(S(y1))))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y1))) S tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(S(y1))), Cons(S(S(S(y0))), z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(S(y0), S(y1)), S(S(S(y1))), Cons(S(S(S(y0))), z2), z3), <'(S(S(S(y0))), S(S(S(y1))))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y1))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE]_3, !EQ'_2, <'_2 Compound Symbols: c17, c14_2, c13_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2, c10_1, c4_1, c13_2 ---------------------------------------- (167) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(S(0), Cons(S(z0), x2), x3) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) by APPMIN(S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil))) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), y2))) APPMIN(S(0), Cons(S(z0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y1))) ---------------------------------------- (168) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(S(z0)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c10(APPMIN(S(S(z0)), Nil, Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y0)), z2) -> c10(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y0), y1)), z2) -> c10(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y0), y1)) -> c10(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y0)) -> c10(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) <'(S(S(S(y0))), S(S(S(y1)))) -> c4(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(S(y1))), Cons(S(S(S(y0))), z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(S(y0), S(y1)), S(S(S(y1))), Cons(S(S(S(y0))), z2), z3), <'(S(S(S(y0))), S(S(S(y1))))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y1))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil))) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), y2))) APPMIN(S(0), Cons(S(z0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y1))) S tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(S(y1))), Cons(S(S(S(y0))), z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(S(y0), S(y1)), S(S(S(y1))), Cons(S(S(S(y0))), z2), z3), <'(S(S(S(y0))), S(S(S(y1))))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y1))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil))) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), y2))) APPMIN(S(0), Cons(S(z0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y1))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE]_3, !EQ'_2, <'_2 Compound Symbols: c17, c14_2, c13_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2, c10_1, c4_1, c13_2 ---------------------------------------- (169) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN[ITE][TRUE][ITE](True, S(x0), Cons(0, x1), Cons(S(x0), Cons(0, x1))) -> c9(APPMIN(0, x1, Cons(S(x0), Cons(0, x1)))) by APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Nil), Cons(S(z0), Cons(0, Nil))) -> c9(APPMIN(0, Nil, Cons(S(z0), Cons(0, Nil)))) APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Cons(y0, Cons(y1, y2))), Cons(S(z0), Cons(0, Cons(y0, Cons(y1, y2))))) -> c9(APPMIN(0, Cons(y0, Cons(y1, y2)), Cons(S(z0), Cons(0, Cons(y0, Cons(y1, y2)))))) APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Cons(y0, Nil)), Cons(S(z0), Cons(0, Cons(y0, Nil)))) -> c9(APPMIN(0, Cons(y0, Nil), Cons(S(z0), Cons(0, Cons(y0, Nil))))) ---------------------------------------- (170) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(S(z0)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c10(APPMIN(S(S(z0)), Nil, Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y0)), z2) -> c10(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y0), y1)), z2) -> c10(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y0), y1)) -> c10(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y0)) -> c10(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) <'(S(S(S(y0))), S(S(S(y1)))) -> c4(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(S(y1))), Cons(S(S(S(y0))), z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(S(y0), S(y1)), S(S(S(y1))), Cons(S(S(S(y0))), z2), z3), <'(S(S(S(y0))), S(S(S(y1))))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y1))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil))) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), y2))) APPMIN(S(0), Cons(S(z0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Nil), Cons(S(z0), Cons(0, Nil))) -> c9(APPMIN(0, Nil, Cons(S(z0), Cons(0, Nil)))) APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Cons(y0, Cons(y1, y2))), Cons(S(z0), Cons(0, Cons(y0, Cons(y1, y2))))) -> c9(APPMIN(0, Cons(y0, Cons(y1, y2)), Cons(S(z0), Cons(0, Cons(y0, Cons(y1, y2)))))) APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Cons(y0, Nil)), Cons(S(z0), Cons(0, Cons(y0, Nil)))) -> c9(APPMIN(0, Cons(y0, Nil), Cons(S(z0), Cons(0, Cons(y0, Nil))))) S tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(S(y1))), Cons(S(S(S(y0))), z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(S(y0), S(y1)), S(S(S(y1))), Cons(S(S(S(y0))), z2), z3), <'(S(S(S(y0))), S(S(S(y1))))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y1))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil))) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), y2))) APPMIN(S(0), Cons(S(z0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y1))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE]_3, !EQ'_2, <'_2 Compound Symbols: c17, c14_2, c13_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2, c10_1, c4_1, c13_2 ---------------------------------------- (171) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) by APPMIN(S(S(y0)), Cons(0, z1), Cons(S(S(y0)), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(y0)), Cons(0, z1), Cons(S(S(y0)), Cons(0, z1)))) APPMIN(S(0), Cons(0, z1), Cons(S(0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), Cons(S(0), Cons(0, z1)))) APPMIN(S(z0), Cons(0, Nil), Cons(S(z0), Cons(0, Nil))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Nil), Cons(S(z0), Cons(0, Nil)))) APPMIN(S(z0), Cons(0, Cons(y1, Cons(y2, y3))), Cons(S(z0), Cons(0, Cons(y1, Cons(y2, y3))))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Cons(y1, Cons(y2, y3))), Cons(S(z0), Cons(0, Cons(y1, Cons(y2, y3)))))) APPMIN(S(z0), Cons(0, Cons(y1, Nil)), Cons(S(z0), Cons(0, Cons(y1, Nil)))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Cons(y1, Nil)), Cons(S(z0), Cons(0, Cons(y1, Nil))))) ---------------------------------------- (172) Obligation: Complexity Dependency Tuples Problem Rules: <(S(z0), S(z1)) -> <(z0, z1) <(0, S(z0)) -> True <(z0, 0) -> False remove(z0, Cons(z1, z2)) -> remove[Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove[Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite](True, z0, Cons(z1, z2)) -> z2 !EQ(S(z0), S(z1)) -> !EQ(z0, z1) !EQ(0, S(z0)) -> False !EQ(S(z0), 0) -> False !EQ(0, 0) -> True Tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) APPMIN[ITE][TRUE][ITE](True, S(S(x0)), Cons(0, x1), x2) -> c9(APPMIN(0, x1, x2)) APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, x0), x1) -> c9(APPMIN(0, x0, x1)) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y0)), y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y0)))) -> c7(REMOVE(S(0), Cons(0, Cons(S(0), y0)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(z0)), Cons(S(S(y1)), y2))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(0, y1)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c7(REMOVE(S(S(z0)), Cons(0, Cons(S(0), y1)))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(S(z1)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c9(APPMIN(S(S(z1)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c9(APPMIN(S(S(z1)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c9(APPMIN(S(S(z1)), Nil, Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c9(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y0)), z2) -> c9(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c9(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y0), y1)), z2) -> c9(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c9(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y0), y1)) -> c9(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y0)) -> c9(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y0, y1)), z2) -> c10(APPMIN(0, Cons(y0, y1), z2)) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y0), y1)) -> c10(APPMIN(0, Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y0)) -> c10(APPMIN(0, Nil, Cons(0, y0))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(S(y1)), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(S(y1)), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(S(z0)), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(0, y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(y1), y2)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(y1), y2), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1)), z3) -> c10(APPMIN(S(S(z0)), Cons(S(0), y1), z3)) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y1), y2)) -> c10(APPMIN(S(S(z0)), Nil, Cons(S(y1), y2))) APPMIN[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y1)) -> c10(APPMIN(S(S(z0)), Nil, Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c10(APPMIN(S(0), Cons(0, y1), Cons(S(y2), Cons(0, y3)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y0)), z2) -> c10(APPMIN(S(0), Cons(0, y0), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c10(APPMIN(S(0), Cons(S(y1), y2), Cons(S(y3), Cons(S(y4), y5)))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y0), y1)), z2) -> c10(APPMIN(S(0), Cons(S(y0), y1), z2)) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c10(APPMIN(S(0), Nil, Cons(S(y1), Nil))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y0), y1)) -> c10(APPMIN(S(0), Nil, Cons(S(y0), y1))) APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y0)) -> c10(APPMIN(S(0), Nil, Cons(0, y0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) <'(S(S(S(y0))), S(S(S(y1)))) -> c4(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(S(y1))), Cons(S(S(S(y0))), z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(S(y0), S(y1)), S(S(S(y1))), Cons(S(S(S(y0))), z2), z3), <'(S(S(S(y0))), S(S(S(y1))))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y1))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil))) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), y2))) APPMIN(S(0), Cons(S(z0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y1))) APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Nil), Cons(S(z0), Cons(0, Nil))) -> c9(APPMIN(0, Nil, Cons(S(z0), Cons(0, Nil)))) APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Cons(y0, Cons(y1, y2))), Cons(S(z0), Cons(0, Cons(y0, Cons(y1, y2))))) -> c9(APPMIN(0, Cons(y0, Cons(y1, y2)), Cons(S(z0), Cons(0, Cons(y0, Cons(y1, y2)))))) APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Cons(y0, Nil)), Cons(S(z0), Cons(0, Cons(y0, Nil)))) -> c9(APPMIN(0, Cons(y0, Nil), Cons(S(z0), Cons(0, Cons(y0, Nil))))) APPMIN(S(S(y0)), Cons(0, z1), Cons(S(S(y0)), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(y0)), Cons(0, z1), Cons(S(S(y0)), Cons(0, z1)))) APPMIN(S(0), Cons(0, z1), Cons(S(0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), Cons(S(0), Cons(0, z1)))) APPMIN(S(z0), Cons(0, Nil), Cons(S(z0), Cons(0, Nil))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Nil), Cons(S(z0), Cons(0, Nil)))) APPMIN(S(z0), Cons(0, Cons(y1, Cons(y2, y3))), Cons(S(z0), Cons(0, Cons(y1, Cons(y2, y3))))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Cons(y1, Cons(y2, y3))), Cons(S(z0), Cons(0, Cons(y1, Cons(y2, y3)))))) APPMIN(S(z0), Cons(0, Cons(y1, Nil)), Cons(S(z0), Cons(0, Cons(y1, Nil)))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Cons(y1, Nil)), Cons(S(z0), Cons(0, Cons(y1, Nil))))) S tuples: REMOVE(0, Cons(0, x2)) -> c17 APPMIN(0, Nil, Cons(S(z0), z1)) -> c14(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) REMOVE(S(0), Cons(S(0), x2)) -> c17 APPMIN(S(S(x1)), Cons(0, z1), x3) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c14(MINSORT(remove[Ite](!EQ(z0, z0), S(z0), Cons(S(z0), Nil))), REMOVE(S(z0), Cons(S(z0), Nil))) APPMIN(S(S(x1)), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(S(x1), z1), S(S(x1)), Cons(S(z1), z2))), REMOVE(S(S(x1)), Cons(S(z1), z2))) APPMIN(S(0), Nil, Cons(S(z1), z2)) -> c14(MINSORT(remove[Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c14(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c11(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c11(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c11(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c11(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c11(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c11(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c11(APPMIN(S(S(y0)), Cons(S(y1), y2), Cons(S(S(y0)), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(0), y1))) -> c11(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c11(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c11(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c11(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c11(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c17(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c17(REMOVE[ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c17(REMOVE[ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c17(REMOVE[ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(S(y3)), y4)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(S(0), y3)))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(S(y1)), y2))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1)))) -> c17(REMOVE[ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c17(REMOVE[ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), Cons(S(y4), Cons(0, y5))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(0, y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), Cons(S(y5), Cons(S(y6), y7))), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(y3), y4)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Cons(S(0), y3)), z3), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), Nil)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(S(y3), y4)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)) -> c13(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Cons(0, y3)), <'(S(S(z1)), S(S(z0)))) APPMIN(S(S(S(y1))), Cons(S(S(S(y0))), z2), z3) -> c13(APPMIN[ITE][TRUE][ITE](<(S(y0), S(y1)), S(S(S(y1))), Cons(S(S(S(y0))), z2), z3), <'(S(S(S(y0))), S(S(S(y1))))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(S(y1), y2)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), Nil))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(S(y1), y2))) APPMIN(S(S(z0)), Cons(S(0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y1))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), Cons(S(y2), Cons(0, y3)))) APPMIN(S(0), Cons(S(z0), Cons(0, y1)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5)))) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), z2) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(S(y1), y2)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), Nil)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), Nil))) APPMIN(S(0), Cons(S(z0), Nil), Cons(S(y1), y2)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(S(y1), y2))) APPMIN(S(0), Cons(S(z0), Nil), Cons(0, y1)) -> c13(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y1))) APPMIN(S(S(y0)), Cons(0, z1), Cons(S(S(y0)), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(S(y0)), Cons(0, z1), Cons(S(S(y0)), Cons(0, z1)))) APPMIN(S(0), Cons(0, z1), Cons(S(0), Cons(0, z1))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), Cons(S(0), Cons(0, z1)))) APPMIN(S(z0), Cons(0, Nil), Cons(S(z0), Cons(0, Nil))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Nil), Cons(S(z0), Cons(0, Nil)))) APPMIN(S(z0), Cons(0, Cons(y1, Cons(y2, y3))), Cons(S(z0), Cons(0, Cons(y1, Cons(y2, y3))))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Cons(y1, Cons(y2, y3))), Cons(S(z0), Cons(0, Cons(y1, Cons(y2, y3)))))) APPMIN(S(z0), Cons(0, Cons(y1, Nil)), Cons(S(z0), Cons(0, Cons(y1, Nil)))) -> c13(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, Cons(y1, Nil)), Cons(S(z0), Cons(0, Cons(y1, Nil))))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c14(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c13(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c13(<'(S(S(y0)), S(S(z0)))) Defined Rule Symbols: <_2, remove_2, remove[Ite]_3, !EQ_2 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE]_3, !EQ'_2, <'_2 Compound Symbols: c17, c14_2, c13_1, c9_1, c11_1, c17_1, c7_1, c_1, c17_2, c10_1, c4_1, c13_2