KILLED proof of input_S2dnbYMOSI.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), 220 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), 0 ms] (18) CpxRNTS (19) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms] (20) CpxRNTS (21) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms] (22) CpxRNTS (23) ResultPropagationProof [UPPER BOUND(ID), 4 ms] (24) CpxRNTS (25) IntTrsBoundProof [UPPER BOUND(ID), 102 ms] (26) CpxRNTS (27) IntTrsBoundProof [UPPER BOUND(ID), 55 ms] (28) CpxRNTS (29) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (30) CpxRNTS (31) IntTrsBoundProof [UPPER BOUND(ID), 470 ms] (32) CpxRNTS (33) IntTrsBoundProof [UPPER BOUND(ID), 65 ms] (34) CpxRNTS (35) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (36) CpxRNTS (37) IntTrsBoundProof [UPPER BOUND(ID), 425 ms] (38) CpxRNTS (39) IntTrsBoundProof [UPPER BOUND(ID), 107 ms] (40) CpxRNTS (41) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (42) CpxRNTS (43) IntTrsBoundProof [UPPER BOUND(ID), 2073 ms] (44) CpxRNTS (45) IntTrsBoundProof [UPPER BOUND(ID), 693 ms] (46) CpxRNTS (47) ResultPropagationProof [UPPER BOUND(ID), 0 ms] (48) CpxRNTS (49) IntTrsBoundProof [UPPER BOUND(ID), 8470 ms] (50) CpxRNTS (51) IntTrsBoundProof [UPPER BOUND(ID), 2101 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 [ComplexityIfPolyImplication, 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) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (70) CdtProblem (71) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (72) CdtProblem (73) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (74) CdtProblem (75) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 34 ms] (76) CdtProblem (77) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (78) CdtProblem (79) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (80) CdtProblem (81) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (82) CdtProblem (83) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 32 ms] (84) CdtProblem (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms] (86) CdtProblem (87) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (88) CdtProblem (89) CdtRewritingProof [BOTH BOUNDS(ID, ID), 2 ms] (90) CdtProblem (91) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (92) CdtProblem (93) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 33 ms] (94) CdtProblem (95) CdtInstantiationProof [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) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (108) CdtProblem (109) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (110) CdtProblem (111) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (112) CdtProblem (113) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (114) CdtProblem (115) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (116) CdtProblem (117) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms] (118) CdtProblem (119) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (120) CdtProblem (121) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (122) CdtProblem (123) CdtInstantiationProof [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), 0 ms] (152) CdtProblem (153) CdtForwardInstantiationProof [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) CdtGraphSplitRhsProof [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 (173) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms] (174) CdtProblem (175) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 258 ms] (176) CdtProblem (177) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (178) CdtProblem (179) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (180) CdtProblem (181) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 4 ms] (182) CdtProblem (183) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms] (184) 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: remove(x', Cons(x, xs)) -> remove[Ite][True][Ite](!EQ(x', x), x', Cons(x, xs)) remove(x, Nil) -> Nil 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 goal(xs) -> minsort(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][True][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][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: remove(x', Cons(x, xs)) -> remove[Ite][True][Ite](!EQ(x', x), x', Cons(x, xs)) remove(x, Nil) -> Nil 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 goal(xs) -> minsort(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][True][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][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: remove(x', Cons(x, xs)) -> remove[Ite][True][Ite](!EQ(x', x), x', Cons(x, xs)) remove(x, Nil) -> Nil 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 goal(xs) -> minsort(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][True][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][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: remove(x', Cons(x, xs)) -> remove[Ite][True][Ite](!EQ(x', x), x', Cons(x, xs)) remove(x, Nil) -> Nil 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 goal(xs) -> minsort(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][True][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][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: remove(x', Cons(x, xs)) -> remove[Ite][True][Ite](!EQ(x', x), x', Cons(x, xs)) [1] remove(x, Nil) -> Nil [1] 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] goal(xs) -> minsort(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][True][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][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: remove(x', Cons(x, xs)) -> remove[Ite][True][Ite](!EQ(x', x), x', Cons(x, xs)) [1] remove(x, Nil) -> Nil [1] 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] goal(xs) -> minsort(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][True][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][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: remove(x', Cons(x, xs)) -> remove[Ite][True][Ite](!EQ(x', x), x', Cons(x, xs)) [1] remove(x, Nil) -> Nil [1] 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] goal(xs) -> minsort(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][True][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][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: remove :: S:0 -> Cons:Nil -> Cons:Nil Cons :: S:0 -> Cons:Nil -> Cons:Nil remove[Ite][True][Ite] :: True:False -> S:0 -> Cons:Nil -> Cons:Nil !EQ :: S:0 -> S:0 -> True:False Nil :: Cons:Nil minsort :: Cons:Nil -> Cons:Nil appmin :: S:0 -> Cons:Nil -> Cons:Nil -> Cons:Nil appmin[Ite][True][Ite] :: True:False -> S:0 -> Cons:Nil -> Cons:Nil -> Cons:Nil lt :: S:0 -> S:0 -> True:False notEmpty :: Cons:Nil -> True:False True :: True:False False :: True:False goal :: Cons:Nil -> Cons:Nil 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 goal_1 (c) The following functions are completely defined: remove_2 !EQ_2 lt_2 remove[Ite][True][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][True][Ite](v0, v1, v2) -> Nil [0] appmin[Ite][True][Ite](v0, v1, v2, v3) -> 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: remove(x', Cons(x, xs)) -> remove[Ite][True][Ite](!EQ(x', x), x', Cons(x, xs)) [1] remove(x, Nil) -> Nil [1] 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] goal(xs) -> minsort(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][True][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][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][True][Ite](v0, v1, v2) -> Nil [0] appmin[Ite][True][Ite](v0, v1, v2, v3) -> Nil [0] The TRS has the following type information: remove :: S:0 -> Cons:Nil -> Cons:Nil Cons :: S:0 -> Cons:Nil -> Cons:Nil remove[Ite][True][Ite] :: True:False:null_!EQ:null_lt -> S:0 -> Cons:Nil -> Cons:Nil !EQ :: S:0 -> S:0 -> True:False:null_!EQ:null_lt Nil :: Cons:Nil minsort :: Cons:Nil -> Cons:Nil appmin :: S:0 -> Cons:Nil -> Cons: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 notEmpty :: Cons:Nil -> True:False:null_!EQ:null_lt True :: True:False:null_!EQ:null_lt False :: True:False:null_!EQ:null_lt goal :: Cons:Nil -> Cons:Nil 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: remove(S(x''), Cons(S(y'), xs)) -> remove[Ite][True][Ite](!EQ(x'', y'), S(x''), Cons(S(y'), xs)) [1] remove(0, Cons(S(y''), xs)) -> remove[Ite][True][Ite](False, 0, Cons(S(y''), xs)) [1] remove(S(x1), Cons(0, xs)) -> remove[Ite][True][Ite](False, S(x1), Cons(0, xs)) [1] remove(0, Cons(0, xs)) -> remove[Ite][True][Ite](True, 0, Cons(0, xs)) [1] remove(x', Cons(x, xs)) -> remove[Ite][True][Ite](null_!EQ, x', Cons(x, xs)) [1] remove(x, Nil) -> Nil [1] minsort(Cons(x, xs)) -> appmin(x, xs, Cons(x, xs)) [1] minsort(Nil) -> Nil [1] appmin(S(y1), Cons(S(x2), xs), xs') -> appmin[Ite][True][Ite](lt(x2, y1), S(y1), Cons(S(x2), xs), xs') [1] appmin(S(y2), Cons(0, xs), xs') -> appmin[Ite][True][Ite](True, S(y2), 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(x3, xs'')) -> Cons(min, minsort(remove[Ite][True][Ite](!EQ(min, x3), min, Cons(x3, xs'')))) [2] appmin(min, Nil, Nil) -> Cons(min, minsort(Nil)) [2] notEmpty(Cons(x, xs)) -> True [1] notEmpty(Nil) -> False [1] goal(xs) -> minsort(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][True][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][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][True][Ite](v0, v1, v2) -> Nil [0] appmin[Ite][True][Ite](v0, v1, v2, v3) -> Nil [0] The TRS has the following type information: remove :: S:0 -> Cons:Nil -> Cons:Nil Cons :: S:0 -> Cons:Nil -> Cons:Nil remove[Ite][True][Ite] :: True:False:null_!EQ:null_lt -> S:0 -> Cons:Nil -> Cons:Nil !EQ :: S:0 -> S:0 -> True:False:null_!EQ:null_lt Nil :: Cons:Nil minsort :: Cons:Nil -> Cons:Nil appmin :: S:0 -> Cons:Nil -> Cons: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 notEmpty :: Cons:Nil -> True:False:null_!EQ:null_lt True :: True:False:null_!EQ:null_lt False :: True:False:null_!EQ:null_lt goal :: Cons:Nil -> Cons:Nil 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(x2, y1), 1 + y1, 1 + (1 + x2) + xs, xs') :|: z = 1 + y1, z'' = xs', y1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, xs' >= 0, x2 >= 0 appmin(z, z', z'') -{ 1 }-> appmin[Ite][True][Ite](2, 1 + y2, 1 + 0 + xs, xs') :|: z'' = xs', xs >= 0, z' = 1 + 0 + xs, xs' >= 0, z = 1 + y2, y2 >= 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][True][Ite](!EQ(min, x3), min, 1 + x3 + xs'')) :|: z'' = 1 + x3 + xs'', xs'' >= 0, z = min, min >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 1 + min + minsort(0) :|: z'' = 0, 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 goal(z) -{ 1 }-> minsort(xs) :|: xs >= 0, z = xs 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][True][Ite](2, 0, 1 + 0 + xs) :|: xs >= 0, z' = 1 + 0 + xs, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + x1, 1 + 0 + xs) :|: xs >= 0, x1 >= 0, z' = 1 + 0 + xs, z = 1 + x1 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, x', 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, x >= 0, z = x' remove(z, z') -{ 1 }-> remove[Ite][True][Ite](!EQ(x'', y'), 1 + x'', 1 + (1 + y') + xs) :|: z = 1 + x'', xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, x'' >= 0 remove(z, z') -{ 1 }-> 0 :|: x >= 0, z = x, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, z' = x', xs >= 0, x' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 remove[Ite][True][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(x2, z - 1), 1 + (z - 1), 1 + (1 + x2) + xs, z'') :|: z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](!EQ(z, x3), z, 1 + x3 + xs'')) :|: z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](!EQ(z - 1, y'), 1 + (z - 1), 1 + (1 + y') + xs) :|: xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite], remove } { appmin, minsort, appmin[Ite][True][Ite] } { goal } ---------------------------------------- (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(x2, z - 1), 1 + (z - 1), 1 + (1 + x2) + xs, z'') :|: z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](!EQ(z, x3), z, 1 + x3 + xs'')) :|: z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](!EQ(z - 1, y'), 1 + (z - 1), 1 + (1 + y') + xs) :|: xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]}, {goal} ---------------------------------------- (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(x2, z - 1), 1 + (z - 1), 1 + (1 + x2) + xs, z'') :|: z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](!EQ(z, x3), z, 1 + x3 + xs'')) :|: z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](!EQ(z - 1, y'), 1 + (z - 1), 1 + (1 + y') + xs) :|: xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]}, {goal} ---------------------------------------- (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(x2, z - 1), 1 + (z - 1), 1 + (1 + x2) + xs, z'') :|: z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](!EQ(z, x3), z, 1 + x3 + xs'')) :|: z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](!EQ(z - 1, y'), 1 + (z - 1), 1 + (1 + y') + xs) :|: xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]}, {goal} 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(x2, z - 1), 1 + (z - 1), 1 + (1 + x2) + xs, z'') :|: z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](!EQ(z, x3), z, 1 + x3 + xs'')) :|: z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](!EQ(z - 1, y'), 1 + (z - 1), 1 + (1 + y') + xs) :|: xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]}, {goal} 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(x2, z - 1), 1 + (z - 1), 1 + (1 + x2) + xs, z'') :|: z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](!EQ(z, x3), z, 1 + x3 + xs'')) :|: z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](!EQ(z - 1, y'), 1 + (z - 1), 1 + (1 + y') + xs) :|: xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]}, {goal} 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(x2, z - 1), 1 + (z - 1), 1 + (1 + x2) + xs, z'') :|: z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](!EQ(z, x3), z, 1 + x3 + xs'')) :|: z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](!EQ(z - 1, y'), 1 + (z - 1), 1 + (1 + y') + xs) :|: xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]}, {goal} 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(x2, z - 1), 1 + (z - 1), 1 + (1 + x2) + xs, z'') :|: z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](!EQ(z, x3), z, 1 + x3 + xs'')) :|: z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](!EQ(z - 1, y'), 1 + (z - 1), 1 + (1 + y') + xs) :|: xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]}, {goal} 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(x2, z - 1), 1 + (z - 1), 1 + (1 + x2) + xs, z'') :|: z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](s', z, 1 + x3 + xs'')) :|: s' >= 0, s' <= 2, z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](s, 1 + (z - 1), 1 + (1 + y') + xs) :|: s >= 0, s <= 2, xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]}, {goal} 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(x2, z - 1), 1 + (z - 1), 1 + (1 + x2) + xs, z'') :|: z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](s', z, 1 + x3 + xs'')) :|: s' >= 0, s' <= 2, z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](s, 1 + (z - 1), 1 + (1 + y') + xs) :|: s >= 0, s <= 2, xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]}, {goal} 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(x2, z - 1), 1 + (z - 1), 1 + (1 + x2) + xs, z'') :|: z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](s', z, 1 + x3 + xs'')) :|: s' >= 0, s' <= 2, z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](s, 1 + (z - 1), 1 + (1 + y') + xs) :|: s >= 0, s <= 2, xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]}, {goal} 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 + x2) + xs, z'') :|: s1 >= 0, s1 <= 2, z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](s', z, 1 + x3 + xs'')) :|: s' >= 0, s' <= 2, z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](s, 1 + (z - 1), 1 + (1 + y') + xs) :|: s >= 0, s <= 2, xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]}, {goal} 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][True][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 + x2) + xs, z'') :|: s1 >= 0, s1 <= 2, z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](s', z, 1 + x3 + xs'')) :|: s' >= 0, s' <= 2, z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](s, 1 + (z - 1), 1 + (1 + y') + xs) :|: s >= 0, s <= 2, xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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][True][Ite],remove}, {appmin,minsort,appmin[Ite][True][Ite]}, {goal} 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][True][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][True][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 + x2) + xs, z'') :|: s1 >= 0, s1 <= 2, z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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][True][Ite](s', z, 1 + x3 + xs'')) :|: s' >= 0, s' <= 2, z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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][True][Ite](s, 1 + (z - 1), 1 + (1 + y') + xs) :|: s >= 0, s <= 2, xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](2, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 0, 1 + (1 + y'') + xs) :|: xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](1, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 1 }-> remove[Ite][True][Ite](0, z, 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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]}, {goal} 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][True][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 + x2) + xs, z'') :|: s1 >= 0, s1 <= 2, z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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 + x3 + xs'' }-> 1 + z + minsort(s8) :|: s8 >= 0, s8 <= 1 + x3 + xs'', s' >= 0, s' <= 2, z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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 + y' }-> s3 :|: s3 >= 0, s3 <= 1 + (1 + y') + xs, s >= 0, s <= 2, xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 6 + xs + y'' }-> s4 :|: s4 >= 0, s4 <= 1 + (1 + y'') + xs, xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 4 + z' }-> s5 :|: s5 >= 0, s5 <= 1 + 0 + (z' - 1), z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 4 + z' }-> s6 :|: s6 >= 0, s6 <= 1 + 0 + (z' - 1), z' - 1 >= 0, z = 0 remove(z, z') -{ 5 + x + xs }-> s7 :|: s7 >= 0, s7 <= 1 + x + xs, xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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]}, {goal} 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][True][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 + x2) + xs, z'') :|: s1 >= 0, s1 <= 2, z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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 + x3 + xs'' }-> 1 + z + minsort(s8) :|: s8 >= 0, s8 <= 1 + x3 + xs'', s' >= 0, s' <= 2, z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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 + y' }-> s3 :|: s3 >= 0, s3 <= 1 + (1 + y') + xs, s >= 0, s <= 2, xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 6 + xs + y'' }-> s4 :|: s4 >= 0, s4 <= 1 + (1 + y'') + xs, xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 4 + z' }-> s5 :|: s5 >= 0, s5 <= 1 + 0 + (z' - 1), z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 4 + z' }-> s6 :|: s6 >= 0, s6 <= 1 + 0 + (z' - 1), z' - 1 >= 0, z = 0 remove(z, z') -{ 5 + x + xs }-> s7 :|: s7 >= 0, s7 <= 1 + x + xs, xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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]}, {goal} 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][True][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 + x2) + xs, z'') :|: s1 >= 0, s1 <= 2, z - 1 >= 0, xs >= 0, z' = 1 + (1 + x2) + xs, z'' >= 0, x2 >= 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 + x3 + xs'' }-> 1 + z + minsort(s8) :|: s8 >= 0, s8 <= 1 + x3 + xs'', s' >= 0, s' <= 2, z'' = 1 + x3 + xs'', xs'' >= 0, z >= 0, x3 >= 0, z' = 0 appmin(z, z', z'') -{ 2 }-> 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 goal(z) -{ 1 }-> minsort(z) :|: z >= 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 + y' }-> s3 :|: s3 >= 0, s3 <= 1 + (1 + y') + xs, s >= 0, s <= 2, xs >= 0, z' = 1 + (1 + y') + xs, y' >= 0, z - 1 >= 0 remove(z, z') -{ 6 + xs + y'' }-> s4 :|: s4 >= 0, s4 <= 1 + (1 + y'') + xs, xs >= 0, z' = 1 + (1 + y'') + xs, y'' >= 0, z = 0 remove(z, z') -{ 4 + z' }-> s5 :|: s5 >= 0, s5 <= 1 + 0 + (z' - 1), z' - 1 >= 0, z - 1 >= 0 remove(z, z') -{ 4 + z' }-> s6 :|: s6 >= 0, s6 <= 1 + 0 + (z' - 1), z' - 1 >= 0, z = 0 remove(z, z') -{ 5 + x + xs }-> s7 :|: s7 >= 0, s7 <= 1 + x + xs, xs >= 0, z' = 1 + x + xs, z >= 0, x >= 0 remove(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0 remove[Ite][True][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]}, {goal} 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][True][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][True][Ite](v0, v1, v2) -> null_remove[Ite][True][Ite] [0] appmin[Ite][True][Ite](v0, v1, v2, v3) -> null_appmin[Ite][True][Ite] [0] remove(v0, v1) -> null_remove [0] minsort(v0) -> null_minsort [0] appmin(v0, v1, v2) -> null_appmin [0] notEmpty(v0) -> null_notEmpty [0] And the following fresh constants: null_!EQ, null_lt, null_remove[Ite][True][Ite], null_appmin[Ite][True][Ite], null_remove, null_minsort, null_appmin, null_notEmpty ---------------------------------------- (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: remove(x', Cons(x, xs)) -> remove[Ite][True][Ite](!EQ(x', x), x', Cons(x, xs)) [1] remove(x, Nil) -> Nil [1] 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] goal(xs) -> minsort(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][True][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][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][True][Ite](v0, v1, v2) -> null_remove[Ite][True][Ite] [0] appmin[Ite][True][Ite](v0, v1, v2, v3) -> null_appmin[Ite][True][Ite] [0] remove(v0, v1) -> null_remove [0] minsort(v0) -> null_minsort [0] appmin(v0, v1, v2) -> null_appmin [0] notEmpty(v0) -> null_notEmpty [0] The TRS has the following type information: remove :: S:0 -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin Cons :: S:0 -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin remove[Ite][True][Ite] :: True:False:null_!EQ:null_lt:null_notEmpty -> S:0 -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin !EQ :: S:0 -> S:0 -> True:False:null_!EQ:null_lt:null_notEmpty Nil :: Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin minsort :: Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin appmin :: S:0 -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin appmin[Ite][True][Ite] :: True:False:null_!EQ:null_lt:null_notEmpty -> S:0 -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin lt :: S:0 -> S:0 -> True:False:null_!EQ:null_lt:null_notEmpty notEmpty :: Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin -> 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 goal :: Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin -> Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin 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][True][Ite] :: Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin null_appmin[Ite][True][Ite] :: Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin null_remove :: Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin null_minsort :: Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin null_appmin :: Cons:Nil:null_remove[Ite][True][Ite]:null_appmin[Ite][True][Ite]:null_remove:null_minsort:null_appmin null_notEmpty :: True:False:null_!EQ:null_lt:null_notEmpty 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][True][Ite] => 0 null_appmin[Ite][True][Ite] => 0 null_remove => 0 null_minsort => 0 null_appmin => 0 null_notEmpty => 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 goal(z) -{ 1 }-> minsort(xs) :|: xs >= 0, z = xs 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][True][Ite](!EQ(x', x), x', 1 + x + xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, x >= 0, z = x' remove(z, z') -{ 1 }-> 0 :|: x >= 0, z = x, z' = 0 remove(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1 remove[Ite][True][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, z' = x', xs >= 0, x' >= 0, x >= 0, z'' = 1 + x + xs remove[Ite][True][Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0 remove[Ite][True][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][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][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) remove(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil 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 goal(z0) -> minsort(z0) 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][TRUE][ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Cons(z1, z2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) MINSORT(Nil) -> c14 APPMIN(z0, Cons(z1, z2), z3) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) NOTEMPTY(Cons(z0, z1)) -> c17 NOTEMPTY(Nil) -> c18 GOAL(z0) -> c19(MINSORT(z0)) S tuples: REMOVE(z0, Cons(z1, z2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) MINSORT(Nil) -> c14 APPMIN(z0, Cons(z1, z2), z3) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) NOTEMPTY(Cons(z0, z1)) -> c17 NOTEMPTY(Nil) -> c18 GOAL(z0) -> c19(MINSORT(z0)) K tuples:none Defined Rule Symbols: remove_2, minsort_1, appmin_3, notEmpty_1, goal_1, !EQ_2, <_2, remove[Ite][True][Ite]_3, appmin[Ite][True][Ite]_4 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3, NOTEMPTY_1, GOAL_1 Compound Symbols: c_1, c1, c2, c3, c4_1, c5, c6, c7_1, c8, c9_1, c10_1, c11_2, c12, c13_1, c14, c15_2, c16_2, c17, c18, c19_1 ---------------------------------------- (59) CdtLeafRemovalProof (ComplexityIfPolyImplication) Removed 1 leading nodes: GOAL(z0) -> c19(MINSORT(z0)) Removed 9 trailing nodes: <'(z0, 0) -> c6 NOTEMPTY(Nil) -> c18 <'(0, S(z0)) -> c5 !EQ'(S(z0), 0) -> c2 MINSORT(Nil) -> c14 REMOVE[ITE][TRUE][ITE](True, z0, Cons(z1, z2)) -> c8 !EQ'(0, S(z0)) -> c1 NOTEMPTY(Cons(z0, z1)) -> c17 !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][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][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) remove(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil 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 goal(z0) -> minsort(z0) Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Cons(z1, z2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Cons(z1, z2), z3) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) S tuples: REMOVE(z0, Cons(z1, z2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Cons(z1, z2), z3) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) K tuples:none Defined Rule Symbols: remove_2, minsort_1, appmin_3, notEmpty_1, goal_1, !EQ_2, <_2, remove[Ite][True][Ite]_3, appmin[Ite][True][Ite]_4 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_2, c12, c13_1, c15_2, c16_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 goal(z0) -> minsort(z0) ---------------------------------------- (62) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Cons(z1, z2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Cons(z1, z2), z3) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) S tuples: REMOVE(z0, Cons(z1, z2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Cons(z1, z2), z3) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) K tuples:none Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c11_2, c12, c13_1, c15_2, c16_2 ---------------------------------------- (63) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace REMOVE(z0, Cons(z1, z2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), z0, Cons(z1, z2)), !EQ'(z0, z1)) by REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2)), !EQ'(0, S(z0))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2)), !EQ'(S(z0), 0)) REMOVE(0, Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](True, 0, Cons(0, x2)), !EQ'(0, 0)) ---------------------------------------- (64) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Cons(z1, z2), z3) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2)), !EQ'(0, S(z0))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2)), !EQ'(S(z0), 0)) REMOVE(0, Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](True, 0, Cons(0, x2)), !EQ'(0, 0)) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Cons(z1, z2), z3) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2)), !EQ'(0, S(z0))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2)), !EQ'(S(z0), 0)) REMOVE(0, Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](True, 0, Cons(0, x2)), !EQ'(0, 0)) K tuples:none Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c15_2, c16_2, c11_2 ---------------------------------------- (65) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 4 trailing tuple parts ---------------------------------------- (66) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Cons(z1, z2), z3) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Cons(z1, z2), z3) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 K tuples:none Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c15_2, c16_2, c11_2, c11_1, c11 ---------------------------------------- (67) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace APPMIN(z0, Cons(z1, z2), z3) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), z0, Cons(z1, z2), z3), <'(z1, z0)) by APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3), <'(0, S(z0))) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3), <'(z0, 0)) ---------------------------------------- (68) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3), <'(0, S(z0))) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3), <'(z0, 0)) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3), <'(0, S(z0))) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3), <'(z0, 0)) K tuples:none Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c16_2, c11_2, c11_1, c11, c15_2 ---------------------------------------- (69) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (70) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) K tuples:none Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c16_2, c11_2, c11_1, c11, c15_2, c15_1 ---------------------------------------- (71) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace APPMIN(z0, Nil, z1) -> c16(MINSORT(remove(z0, z1)), REMOVE(z0, z1)) by APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) APPMIN(z0, Nil, Nil) -> c16(MINSORT(Nil), REMOVE(z0, Nil)) ---------------------------------------- (72) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) APPMIN(z0, Nil, Nil) -> c16(MINSORT(Nil), REMOVE(z0, Nil)) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) APPMIN(z0, Nil, Nil) -> c16(MINSORT(Nil), REMOVE(z0, Nil)) K tuples:none Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c11_2, c11_1, c11, c15_2, c15_1, c16_2 ---------------------------------------- (73) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (74) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) K tuples:none Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c11_2, c11_1, c11, c15_2, c15_1, c16_2, c16_1 ---------------------------------------- (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(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) We considered the (Usable) Rules:none And the Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) 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)) = x_3 POL(APPMIN[ITE][TRUE][ITE](x_1, x_2, x_3, x_4)) = x_4 POL(Cons(x_1, x_2)) = 0 POL(False) = 0 POL(MINSORT(x_1)) = 0 POL(Nil) = [1] POL(REMOVE(x_1, x_2)) = 0 POL(REMOVE[ITE][TRUE][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) = 0 POL(c11(x_1)) = x_1 POL(c11(x_1, x_2)) = x_1 + x_2 POL(c12) = 0 POL(c13(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c16(x_1)) = x_1 POL(c16(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][True][Ite](x_1, x_2, x_3)) = [1] + x_2 + x_3 ---------------------------------------- (76) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(z0), Cons(S(z1), x2)), !EQ'(S(z0), S(z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c11_2, c11_1, c11, c15_2, c15_1, c16_2, c16_1 ---------------------------------------- (77) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace REMOVE(S(z0), Cons(S(z1), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(0), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](True, S(0), Cons(S(0), x2)), !EQ'(S(0), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) ---------------------------------------- (78) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(0), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](True, S(0), Cons(S(0), x2)), !EQ'(S(0), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(0), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](True, S(0), Cons(S(0), x2)), !EQ'(S(0), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c11_1, c11, c15_2, c15_1, c16_2, c16_1, c11_2 ---------------------------------------- (79) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing tuple parts ---------------------------------------- (80) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](<(z0, z1), S(z1), Cons(S(z0), x2), x3), <'(S(z0), S(z1))) APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c11_1, c11, c15_2, c15_1, c16_2, c16_1, c11_2 ---------------------------------------- (81) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace APPMIN(S(z1), Cons(S(z0), x2), x3) -> c15(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) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) ---------------------------------------- (82) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c11_1, c11, c15_1, c16_2, c16_1, c11_2, c15_2 ---------------------------------------- (83) 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) -> c15(<'(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][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(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] POL(APPMIN[ITE][TRUE][ITE](x_1, x_2, x_3, x_4)) = x_1 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][TRUE][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) = 0 POL(c11(x_1)) = x_1 POL(c11(x_1, x_2)) = x_1 + x_2 POL(c12) = 0 POL(c13(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c16(x_1)) = x_1 POL(c16(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][True][Ite](x_1, x_2, x_3)) = [1] + x_2 + x_3 ---------------------------------------- (84) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c11_1, c11, c15_1, c16_2, c16_1, c11_2, c15_2 ---------------------------------------- (85) CdtNarrowingProof (BOTH BOUNDS(ID, ID)) Use narrowing to replace APPMIN(z0, Nil, Cons(z1, z2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2))), REMOVE(z0, Cons(z1, z2))) by APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), x2)) -> c16(MINSORT(remove[Ite][True][Ite](False, 0, Cons(S(z0), x2))), REMOVE(0, Cons(S(z0), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) ---------------------------------------- (86) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), x2)) -> c16(MINSORT(remove[Ite][True][Ite](False, 0, Cons(S(z0), x2))), REMOVE(0, Cons(S(z0), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), x2)) -> c16(MINSORT(remove[Ite][True][Ite](False, 0, Cons(S(z0), x2))), REMOVE(0, Cons(S(z0), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c11_1, c11, c15_1, c16_1, c11_2, c15_2, c16_2 ---------------------------------------- (87) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace APPMIN(0, Nil, Cons(S(z0), x2)) -> c16(MINSORT(remove[Ite][True][Ite](False, 0, Cons(S(z0), x2))), REMOVE(0, Cons(S(z0), x2))) by APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) ---------------------------------------- (88) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(S(z0), Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) APPMIN(0, Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c11_1, c11, c15_1, c16_1, c11_2, c15_2, c16_2 ---------------------------------------- (89) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace APPMIN(S(z0), Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](False, S(z0), Cons(0, x2))), REMOVE(S(z0), Cons(0, x2))) by APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) ---------------------------------------- (90) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c11_1, c11, c15_1, c16_1, c11_2, c15_2, c16_2 ---------------------------------------- (91) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace APPMIN(0, Nil, Cons(0, x2)) -> c16(MINSORT(remove[Ite][True][Ite](True, 0, Cons(0, x2))), REMOVE(0, Cons(0, x2))) by APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) ---------------------------------------- (92) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c11_1, c11, c15_1, c16_1, c11_2, c15_2, c16_2 ---------------------------------------- (93) 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)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) We considered the (Usable) Rules: remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 remove(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil And the Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(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) = [1] POL(<(x_1, x_2)) = [1] 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)) = x_1 + x_2 POL(False) = 0 POL(MINSORT(x_1)) = x_1 POL(Nil) = 0 POL(REMOVE(x_1, x_2)) = 0 POL(REMOVE[ITE][TRUE][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) = 0 POL(c11(x_1)) = x_1 POL(c11(x_1, x_2)) = x_1 + x_2 POL(c12) = 0 POL(c13(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c16(x_1)) = x_1 POL(c16(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][True][Ite](x_1, x_2, x_3)) = x_3 ---------------------------------------- (94) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE[ITE][TRUE][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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3 Compound Symbols: c_1, c4_1, c7_1, c9_1, c10_1, c12, c13_1, c11_1, c11, c15_1, c16_1, c11_2, c15_2, c16_2 ---------------------------------------- (95) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace REMOVE[ITE][TRUE][ITE](False, z0, Cons(z1, z2)) -> c7(REMOVE(z0, z2)) by REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) ---------------------------------------- (96) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 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)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3 Compound Symbols: c_1, c4_1, c9_1, c10_1, c12, c13_1, c11_1, c11, c15_1, c16_1, c11_2, c15_2, c16_2, c7_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: !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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) APPMIN[ITE][TRUE][ITE](False, z0, Cons(z1, z2), z3) -> c10(APPMIN(z0, z2, z3)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, APPMIN[ITE][TRUE][ITE]_4, REMOVE_2, MINSORT_1, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3 Compound Symbols: c_1, c4_1, c10_1, c12, c13_1, c11_1, c11, c15_1, c16_1, c11_2, c15_2, c16_2, c7_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: !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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE_2, MINSORT_1, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4 Compound Symbols: c_1, c4_1, c12, c13_1, c11_1, c11, c15_1, c16_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1 ---------------------------------------- (101) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace APPMIN(S(z0), Cons(0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, x2), x3)) by APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) ---------------------------------------- (102) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) K tuples: APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE_2, MINSORT_1, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4 Compound Symbols: c_1, c4_1, c12, c13_1, c11_1, c11, c15_1, c16_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1 ---------------------------------------- (103) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace APPMIN(z0, Nil, Nil) -> c16(REMOVE(z0, Nil)) by APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) ---------------------------------------- (104) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: !EQ'(S(z0), S(z1)) -> c(!EQ'(z0, z1)) <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: !EQ'_2, <'_2, REMOVE_2, MINSORT_1, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4 Compound Symbols: c_1, c4_1, c12, c13_1, c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1 ---------------------------------------- (105) 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))) ---------------------------------------- (106) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2)), !EQ'(S(0), S(S(z0)))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2)), !EQ'(S(S(z0)), S(0))) REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) REMOVE(S(0), Cons(S(0), x2)) -> c11(!EQ'(S(0), S(0))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: <'_2, REMOVE_2, MINSORT_1, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2 Compound Symbols: c4_1, c12, c13_1, c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1 ---------------------------------------- (107) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 3 trailing tuple parts ---------------------------------------- (108) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: <'(S(z0), S(z1)) -> c4(<'(z0, z1)) REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 S tuples: REMOVE(z0, Nil) -> c12 MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: <'_2, REMOVE_2, MINSORT_1, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2 Compound Symbols: c4_1, c12, c13_1, c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1 ---------------------------------------- (109) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace REMOVE(z0, Nil) -> c12 by REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 ---------------------------------------- (110) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: <'(S(z0), S(z1)) -> c4(<'(z0, z1)) MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 S tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 K tuples: APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: <'_2, MINSORT_1, REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2 Compound Symbols: c4_1, c13_1, c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12 ---------------------------------------- (111) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace APPMIN(S(x0), Cons(S(x1), x2), x3) -> c15(<'(S(x1), S(x0))) by APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) APPMIN(S(0), Cons(S(z1), z2), x2) -> c15(<'(S(z1), S(0))) ---------------------------------------- (112) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: <'(S(z0), S(z1)) -> c4(<'(z0, z1)) MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) APPMIN(S(0), Cons(S(z1), z2), x2) -> c15(<'(S(z1), S(0))) S tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) APPMIN(S(0), Cons(S(z1), z2), x2) -> c15(<'(S(z1), S(0))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: <'_2, MINSORT_1, REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2 Compound Symbols: c4_1, c13_1, c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12 ---------------------------------------- (113) 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))) ---------------------------------------- (114) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) APPMIN(S(0), Cons(S(z1), z2), x2) -> c15(<'(S(z1), S(0))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) S tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) APPMIN(S(0), Cons(S(z1), z2), x2) -> c15(<'(S(z1), S(0))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: MINSORT_1, REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2 Compound Symbols: c13_1, c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12, c4_1 ---------------------------------------- (115) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: APPMIN(S(0), Cons(S(z1), z2), x2) -> c15(<'(S(z1), S(0))) ---------------------------------------- (116) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) S tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3), <'(S(z0), S(0))) APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: MINSORT_1, REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2 Compound Symbols: c13_1, c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12, c4_1 ---------------------------------------- (117) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID)) Removed 2 trailing tuple parts ---------------------------------------- (118) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) S tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(z0, z1), S(z0), Cons(S(z1), x2))), REMOVE(S(z0), Cons(S(z1), x2))) APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: MINSORT_1, REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2 Compound Symbols: c13_1, c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12, c4_1 ---------------------------------------- (119) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace APPMIN(S(z0), Nil, Cons(S(z1), x2)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) ---------------------------------------- (120) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][Ite](!EQ(0, z1), S(0), Cons(S(z1), z2))), REMOVE(S(0), Cons(S(z1), z2))) S tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: MINSORT_1, REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2 Compound Symbols: c13_1, c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12, c4_1 ---------------------------------------- (121) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace APPMIN(S(z0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(z0), z1))), REMOVE(S(z0), Cons(0, z1))) by APPMIN(S(S(x1)), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) ---------------------------------------- (122) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) S tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: MINSORT_1, REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2 Compound Symbols: c13_1, c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12, c4_1 ---------------------------------------- (123) 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)) ---------------------------------------- (124) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: MINSORT_1, REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2 Compound Symbols: c13_1, c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12, c4_1 ---------------------------------------- (125) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace MINSORT(Cons(z0, z1)) -> c13(APPMIN(z0, z1, Cons(z0, z1))) by MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) ---------------------------------------- (126) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) S tuples: REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(!EQ'(S(x0), S(x1))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1 Compound Symbols: c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12, c4_1, c13_1 ---------------------------------------- (127) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE(S(x0), Cons(S(x1), x2)) -> c11(!EQ'(S(x0), S(x1))) by REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) ---------------------------------------- (128) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) S tuples: REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1 Compound Symbols: c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12, c4_1, c13_1 ---------------------------------------- (129) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(x0), x1)) -> c7(REMOVE(0, x1)) by REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) ---------------------------------------- (130) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) S tuples: REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1 Compound Symbols: c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12, c4_1, c13_1 ---------------------------------------- (131) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE(0, Cons(S(z0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), x2))) by REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) ---------------------------------------- (132) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) S tuples: REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1 Compound Symbols: c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12, c4_1, c13_1 ---------------------------------------- (133) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE[ITE][TRUE][ITE](False, S(x0), Cons(0, x1)) -> c7(REMOVE(S(x0), x1)) by REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) ---------------------------------------- (134) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) S tuples: REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1 Compound Symbols: c11_1, c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c12, c4_1, c13_1 ---------------------------------------- (135) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE(S(z0), Cons(0, x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, x2))) by REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) ---------------------------------------- (136) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1 Compound Symbols: c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c11_1, c12, c4_1, c13_1 ---------------------------------------- (137) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(S(x1)), x2)) -> c7(REMOVE(S(S(x0)), x2)) by REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) ---------------------------------------- (138) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1 Compound Symbols: c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c11_1, c12, c4_1, c13_1 ---------------------------------------- (139) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(x0)), x1)) -> c7(REMOVE(S(0), x1)) by REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) ---------------------------------------- (140) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, REMOVE[ITE][TRUE][ITE]_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1 Compound Symbols: c11, c15_1, c11_2, c15_2, c16_2, c7_1, c9_1, c10_1, c16_1, c_1, c11_1, c12, c4_1, c13_1 ---------------------------------------- (141) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE[ITE][TRUE][ITE](False, S(S(x0)), Cons(S(0), x1)) -> c7(REMOVE(S(S(x0)), x1)) by REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) ---------------------------------------- (142) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3 Compound Symbols: c11, c15_1, c11_2, c15_2, c16_2, c9_1, c10_1, c16_1, c_1, c11_1, c12, c4_1, c13_1, c7_1 ---------------------------------------- (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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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: !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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3 Compound Symbols: c11, c15_1, c11_2, c15_2, c16_2, c9_1, c10_1, c16_1, c_1, c11_1, c12, c4_1, c13_1, c7_1 ---------------------------------------- (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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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: !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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3 Compound Symbols: c11, c15_1, c11_2, c15_2, c16_2, c10_1, c16_1, c_1, c11_1, c12, c4_1, c9_1, c13_1, c7_1 ---------------------------------------- (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))) APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) ---------------------------------------- (148) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3 Compound Symbols: c11, c15_1, c11_2, c15_2, c16_2, c10_1, c16_1, c_1, c11_1, c12, c4_1, c9_1, c13_1, c7_1 ---------------------------------------- (149) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(0, Cons(z0, x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, x2), x3)) by APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) ---------------------------------------- (150) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) S tuples: REMOVE(0, Cons(0, x2)) -> c11 REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3 Compound Symbols: c11, c11_2, c15_2, c16_2, c10_1, c15_1, c16_1, c_1, c11_1, c12, c4_1, c9_1, c13_1, c7_1 ---------------------------------------- (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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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: !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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) 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))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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)) -> c11 REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, !EQ'_2, <'_2, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3 Compound Symbols: c11, c11_2, c15_2, c16_2, c10_1, c15_1, c16_1, c_1, c11_1, c12, c4_1, c9_1, c13_1, c7_1 ---------------------------------------- (153) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) ---------------------------------------- (154) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) !EQ'(S(S(y0)), S(S(y1))) -> c(!EQ'(S(y0), S(y1))) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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)) -> c11 REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, !EQ'_2, <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3 Compound Symbols: c11, c11_2, c15_2, c16_2, c15_1, c16_1, c_1, c11_1, c12, c4_1, c9_1, c13_1, c7_1, c10_1 ---------------------------------------- (155) 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)))) ---------------------------------------- (156) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c(!EQ'(S(S(y0)), S(S(y1)))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), x2)), !EQ'(S(S(z0)), S(S(z1)))) APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2 Compound Symbols: c11, c11_2, c15_2, c16_2, c15_1, c16_1, c11_1, c12, c4_1, c9_1, c13_1, c7_1, c10_1, c_1 ---------------------------------------- (157) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE(S(S(z0)), Cons(S(S(z1)), x2)) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c11(REMOVE[ITE][TRUE][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))))) ---------------------------------------- (158) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c11(REMOVE[ITE][TRUE][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: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil)), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Cons(0, y3)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))), !EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c11(REMOVE[ITE][TRUE][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)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2 Compound Symbols: c11, c15_2, c16_2, c15_1, c16_1, c11_1, c12, c4_1, c9_1, c13_1, c7_1, c10_1, c_1, c11_2 ---------------------------------------- (159) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (160) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2 Compound Symbols: c11, c15_2, c16_2, c15_1, c16_1, c11_1, c12, c4_1, c9_1, c13_1, c7_1, c10_1, c_1, c11_2, c1_1 ---------------------------------------- (161) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE(S(0), Cons(S(S(z0)), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), x2))) by REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) ---------------------------------------- (162) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2 Compound Symbols: c11, c15_2, c16_2, c15_1, c16_1, c11_1, c12, c4_1, c9_1, c13_1, c7_1, c10_1, c_1, c11_2, c1_1 ---------------------------------------- (163) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace REMOVE(S(S(z0)), Cons(S(0), x2)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), x2))) by REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) ---------------------------------------- (164) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2 Compound Symbols: c11, c15_2, c16_2, c15_1, c16_1, c12, c4_1, c9_1, c13_1, c11_1, c7_1, c10_1, c_1, c11_2, c1_1 ---------------------------------------- (165) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(S(z0), Cons(S(z1), z2), Cons(S(z0), Cons(S(z1), z2))) -> c15(<'(S(z1), S(z0))) by APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) ---------------------------------------- (166) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2 Compound Symbols: c11, c15_2, c16_2, c15_1, c16_1, c12, c4_1, c9_1, c13_1, c11_1, c7_1, c10_1, c_1, c11_2, c1_1 ---------------------------------------- (167) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(S(S(x1)), Cons(S(z1), z2), x3) -> c15(<'(S(z1), S(S(x1)))) by APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(S(S(y0)), S(S(z0)))) ---------------------------------------- (168) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 <'(S(S(y0)), S(S(y1))) -> c4(<'(S(y0), S(y1))) APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(S(S(y0)), S(S(z0)))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(S(S(y0)), S(S(z0)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, <'_2, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2 Compound Symbols: c11, c15_2, c16_2, c15_1, c16_1, c12, c4_1, c9_1, c13_1, c11_1, c7_1, c10_1, c_1, c11_2, c1_1 ---------------------------------------- (169) 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)))) ---------------------------------------- (170) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(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)) -> c11 APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(S(S(y0)), S(S(z0)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2, <'_2 Compound Symbols: c11, c15_2, c16_2, c15_1, c16_1, c12, c9_1, c13_1, c11_1, c7_1, c10_1, c_1, c11_2, c1_1, c4_1 ---------------------------------------- (171) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(S(S(z1)), Cons(S(S(z0)), x2), x3) -> c15(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) -> c15(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))) -> c15(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) -> c15(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)), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil), <'(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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))))) ---------------------------------------- (172) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(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) -> c15(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))) -> c15(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) -> c15(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)), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil), <'(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c15(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))) -> c15(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) -> c15(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)), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil), <'(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(S(S(y0)), S(S(z0)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2, <'_2 Compound Symbols: c11, c16_2, c15_1, c16_1, c12, c9_1, c13_1, c11_1, c7_1, c10_1, c_1, c11_2, c1_1, c4_1, c15_2 ---------------------------------------- (173) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID)) Split RHS of tuples not part of any SCC ---------------------------------------- (174) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(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) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(S(S(y0)), S(S(z0)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2, <'_2 Compound Symbols: c11, c16_2, c15_1, c16_1, c12, c9_1, c13_1, c11_1, c7_1, c10_1, c_1, c11_2, c1_1, c4_1, c15_2, c2_1 ---------------------------------------- (175) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) We considered the (Usable) Rules:none And the Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(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) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) The order we found is given by the following interpretation: Polynomial interpretation : POL(!EQ(x_1, x_2)) = 0 POL(!EQ'(x_1, x_2)) = x_1 + x_2 POL(0) = 0 POL(<(x_1, x_2)) = [1] POL(<'(x_1, x_2)) = x_1 + x_2 POL(APPMIN(x_1, x_2, x_3)) = x_1 + x_3 POL(APPMIN[ITE][TRUE][ITE](x_1, x_2, x_3, x_4)) = x_2 + x_4 POL(Cons(x_1, x_2)) = 0 POL(False) = 0 POL(MINSORT(x_1)) = 0 POL(Nil) = [1] POL(REMOVE(x_1, x_2)) = x_1 POL(REMOVE[ITE][TRUE][ITE](x_1, x_2, x_3)) = x_2 POL(S(x_1)) = 0 POL(True) = [1] POL(c(x_1)) = x_1 POL(c1(x_1)) = x_1 POL(c10(x_1)) = x_1 POL(c11) = 0 POL(c11(x_1)) = x_1 POL(c11(x_1, x_2)) = x_1 + x_2 POL(c12) = 0 POL(c13(x_1)) = x_1 POL(c15(x_1)) = x_1 POL(c15(x_1, x_2)) = x_1 + x_2 POL(c16(x_1)) = x_1 POL(c16(x_1, x_2)) = x_1 + x_2 POL(c2(x_1)) = x_1 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] POL(remove[Ite][True][Ite](x_1, x_2, x_3)) = [1] + x_2 + x_3 ---------------------------------------- (176) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(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) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), x2), x3)) APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(S(S(y0)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2, <'_2 Compound Symbols: c11, c16_2, c15_1, c16_1, c12, c9_1, c13_1, c11_1, c7_1, c10_1, c_1, c11_2, c1_1, c4_1, c15_2, c2_1 ---------------------------------------- (177) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(S(S(z0)), Cons(S(0), x2), x3) -> c15(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))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y1))) ---------------------------------------- (178) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(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) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y1))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), x2), x3)) APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Cons(0, y1))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(S(S(y0)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2, <'_2 Compound Symbols: c11, c16_2, c15_1, c16_1, c12, c9_1, c13_1, c11_1, c7_1, c10_1, c_1, c11_2, c1_1, c4_1, c15_2, c2_1 ---------------------------------------- (179) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID)) Use forward instantiation to replace APPMIN(S(0), Cons(S(z0), x2), x3) -> c15(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))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Nil)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y1))) ---------------------------------------- (180) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(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) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Nil)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y1))) S tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Nil)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y1))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(S(S(y0)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2, <'_2 Compound Symbols: c11, c16_2, c15_1, c16_1, c12, c9_1, c13_1, c11_1, c7_1, c10_1, c_1, c11_2, c1_1, c4_1, c15_2, c2_1 ---------------------------------------- (181) 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))))) ---------------------------------------- (182) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(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) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Nil)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][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(S(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Nil)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y1))) K tuples: APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(S(S(y0)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2, <'_2 Compound Symbols: c11, c16_2, c15_1, c16_1, c12, c9_1, c13_1, c11_1, c7_1, c10_1, c_1, c11_2, c1_1, c4_1, c15_2, c2_1 ---------------------------------------- (183) CdtRewritingProof (BOTH BOUNDS(ID, ID)) Used rewriting to replace REMOVE(S(S(S(y0))), Cons(S(S(S(y1))), z2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(S(z0))), Cons(S(S(S(z1))), z2)), !EQ'(S(S(S(z0))), S(S(S(z1))))) ---------------------------------------- (184) 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(z0, Cons(z1, z2)) -> remove[Ite][True][Ite](!EQ(z0, z1), z0, Cons(z1, z2)) remove(z0, Nil) -> Nil remove[Ite][True][Ite](False, z0, Cons(z1, z2)) -> Cons(z1, remove(z0, z2)) remove[Ite][True][Ite](True, z0, Cons(z1, z2)) -> z2 Tuples: REMOVE(0, Cons(0, x2)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(0, Nil, Cons(0, z0)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(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))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y0), y1))) -> c7(REMOVE(0, Cons(S(y0), y1))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y0))) -> c7(REMOVE(0, Cons(0, y0))) REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil)) -> c7(REMOVE(0, Nil)) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1))) -> c7(REMOVE(S(z0), Cons(0, y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c7(REMOVE(S(S(y0)), Cons(S(S(y1)), y2))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1))) -> c7(REMOVE(S(S(y0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil)) -> c7(REMOVE(S(z0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil)) -> c7(REMOVE(S(S(y0)), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y0)), y1))) -> c7(REMOVE(S(0), Cons(S(S(y0)), y1))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y0))) -> c7(REMOVE(S(0), Cons(S(0), y0))) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil)) -> c7(REMOVE(S(0), Nil)) REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c7(REMOVE(S(0), Cons(0, Cons(0, y1)))) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c7(REMOVE(S(0), Cons(0, Nil))) REMOVE[ITE][TRUE][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][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c7(REMOVE(S(S(z0)), Cons(S(0), y1))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil)) -> c7(REMOVE(S(S(z0)), Nil)) REMOVE[ITE][TRUE][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][TRUE][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][TRUE][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)))) REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c7(REMOVE(S(S(z0)), Cons(0, Nil))) 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)), Nil), Nil) -> c9(APPMIN(S(S(z1)), Nil, Nil)) 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), Nil), Nil) -> c9(APPMIN(S(0), Nil, Nil)) 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[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil) -> c10(APPMIN(0, Nil, Nil)) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) 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)), Nil), Nil) -> c10(APPMIN(S(S(z0)), Nil, Nil)) 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))) 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), Nil), Nil) -> c10(APPMIN(S(0), Nil, Nil)) 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))) !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))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(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) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Nil)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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))))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c11(REMOVE[ITE][TRUE][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)) -> c11 APPMIN(0, Nil, Cons(S(z0), z1)) -> c16(MINSORT(Cons(S(z0), remove(0, z1))), REMOVE(0, Cons(S(z0), z1))) APPMIN(S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1))) -> c15(APPMIN[ITE][TRUE][ITE](True, S(z0), Cons(0, z1), Cons(S(z0), Cons(0, z1)))) APPMIN(S(S(x1)), Cons(0, z1), x3) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(x1)), Cons(0, z1), x3)) APPMIN(S(0), Cons(0, z1), x2) -> c15(APPMIN[ITE][TRUE][ITE](True, S(0), Cons(0, z1), x2)) REMOVE(S(0), Cons(S(0), x2)) -> c11 REMOVE(0, Nil) -> c12 REMOVE(S(x0), Nil) -> c12 REMOVE(S(S(x0)), Nil) -> c12 REMOVE(S(0), Nil) -> c12 APPMIN(S(z0), Nil, Cons(S(z0), Nil)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(remove[Ite][True][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)) -> c16(MINSORT(Cons(0, remove(S(S(x1)), z1))), REMOVE(S(S(x1)), Cons(0, z1))) APPMIN(S(0), Nil, Cons(0, z1)) -> c16(MINSORT(Cons(0, remove(S(0), z1))), REMOVE(S(0), Cons(0, z1))) MINSORT(Cons(0, Cons(y0, y1))) -> c13(APPMIN(0, Cons(y0, y1), Cons(0, Cons(y0, y1)))) MINSORT(Cons(S(S(y0)), Cons(S(S(y1)), y2))) -> c13(APPMIN(S(S(y0)), Cons(S(S(y1)), y2), Cons(S(S(y0)), Cons(S(S(y1)), y2)))) MINSORT(Cons(0, Nil)) -> c13(APPMIN(0, Nil, Cons(0, Nil))) MINSORT(Cons(S(y0), Cons(0, y1))) -> c13(APPMIN(S(y0), Cons(0, y1), Cons(S(y0), Cons(0, y1)))) MINSORT(Cons(S(S(y0)), Cons(0, y1))) -> c13(APPMIN(S(S(y0)), Cons(0, y1), Cons(S(S(y0)), Cons(0, y1)))) MINSORT(Cons(S(0), Cons(0, y0))) -> c13(APPMIN(S(0), Cons(0, y0), Cons(S(0), Cons(0, y0)))) MINSORT(Cons(S(y0), Cons(S(y1), y2))) -> c13(APPMIN(S(y0), Cons(S(y1), y2), Cons(S(y0), Cons(S(y1), y2)))) MINSORT(Cons(S(S(y0)), Cons(S(y1), y2))) -> c13(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))) -> c13(APPMIN(S(S(y0)), Cons(S(0), y1), Cons(S(S(y0)), Cons(S(0), y1)))) MINSORT(Cons(S(0), Cons(S(y0), y1))) -> c13(APPMIN(S(0), Cons(S(y0), y1), Cons(S(0), Cons(S(y0), y1)))) MINSORT(Cons(S(y0), Nil)) -> c13(APPMIN(S(y0), Nil, Cons(S(y0), Nil))) MINSORT(Cons(S(S(y0)), Nil)) -> c13(APPMIN(S(S(y0)), Nil, Cons(S(S(y0)), Nil))) MINSORT(Cons(S(0), Nil)) -> c13(APPMIN(S(0), Nil, Cons(S(0), Nil))) REMOVE(S(S(y0)), Cons(S(S(y1)), z2)) -> c11(!EQ'(S(S(y0)), S(S(y1)))) REMOVE(0, Cons(S(z0), Cons(S(y1), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(S(y1), y2)))) REMOVE(0, Cons(S(z0), Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Cons(0, y1)))) REMOVE(0, Cons(S(z0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, 0, Cons(S(z0), Nil))) REMOVE(S(z0), Cons(0, Cons(0, y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Cons(0, y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(0, Cons(S(S(y0)), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(S(y0)), y1)))) REMOVE(S(S(y0)), Cons(0, Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Cons(S(0), y1)))) REMOVE(S(0), Cons(0, Cons(S(0), y0))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Cons(S(0), y0)))) REMOVE(S(z0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(z0), Cons(0, Nil))) REMOVE(S(S(y0)), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(y0)), Cons(0, Nil))) REMOVE(S(0), Cons(0, Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(0, Nil))) APPMIN(0, Cons(z0, Cons(y1, y2)), z2) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Cons(y1, y2)), z2)) APPMIN(0, Cons(z0, Nil), Cons(S(y1), y2)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(S(y1), y2))) APPMIN(0, Cons(z0, Nil), Cons(0, y1)) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Cons(0, y1))) APPMIN(0, Cons(z0, Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, 0, Cons(z0, Nil), Nil)) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4))) -> c11(REMOVE[ITE][TRUE][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))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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(z0)), Cons(S(S(z1)), Nil)) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Nil))) REMOVE(S(S(z0)), Cons(S(S(z1)), Nil)) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(REMOVE[ITE][TRUE][ITE](!EQ(z0, z1), S(S(z0)), Cons(S(S(z1)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(S(z1)), Cons(0, Nil))) -> c1(!EQ'(S(S(z0)), S(S(z1)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(S(y1)), y2)))) REMOVE(S(0), Cons(S(S(z0)), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(S(0), y1)))) REMOVE(S(0), Cons(S(S(z0)), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Nil))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Cons(S(0), y1))))) REMOVE(S(0), Cons(S(S(z0)), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(0), Cons(S(S(z0)), Cons(0, Nil)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(S(y1)), y2)))) REMOVE(S(S(z0)), Cons(S(0), Cons(S(0), y1))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(S(0), y1)))) REMOVE(S(S(z0)), Cons(S(0), Nil)) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Nil))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Cons(0, y1)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][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)))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Cons(S(0), y1))))) REMOVE(S(S(z0)), Cons(S(0), Cons(0, Nil))) -> c11(REMOVE[ITE][TRUE][ITE](False, S(S(z0)), Cons(S(0), Cons(0, Nil)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Cons(S(S(y3)), y4)), z3) -> c15(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))) -> c15(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) -> c15(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))) -> c15(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) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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) -> c15(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(S(z1)), Nil), Nil) -> c2(APPMIN[ITE][TRUE][ITE](<(z1, z0), S(S(z0)), Cons(S(S(z1)), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(0, y1)), Cons(S(y2), Cons(0, y3))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Cons(0, y1)), z2)) APPMIN(S(S(z0)), Cons(S(0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](True, S(S(z0)), Cons(S(0), Nil), Nil)) APPMIN(S(S(z0)), Cons(S(0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(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))) -> c15(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) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Cons(0, y1)), z2)) APPMIN(S(0), Cons(S(z0), Nil), Nil) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Nil)) APPMIN(S(0), Cons(S(z0), Cons(S(y1), y2)), Cons(S(y3), Cons(S(y4), y5))) -> c15(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) -> c15(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)) -> c15(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)) -> c15(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)) -> c15(APPMIN[ITE][TRUE][ITE](False, S(0), Cons(S(z0), Nil), Cons(0, y1))) REMOVE(S(S(S(z0))), Cons(S(S(S(z1))), z2)) -> c11(REMOVE[ITE][TRUE][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)) -> c16(MINSORT(z0), REMOVE(0, Cons(0, z0))) APPMIN(0, Nil, Nil) -> c16(REMOVE(0, Nil)) APPMIN(S(S(x1)), Nil, Nil) -> c16(REMOVE(S(S(x1)), Nil)) APPMIN(S(0), Nil, Nil) -> c16(REMOVE(S(0), Nil)) APPMIN(S(S(y1)), Cons(S(S(y0)), z2), Cons(S(S(y1)), Cons(S(S(y0)), z2))) -> c15(<'(S(S(y0)), S(S(y1)))) APPMIN(S(S(z0)), Cons(S(S(y0)), z2), z3) -> c15(<'(S(S(y0)), S(S(z0)))) APPMIN(S(S(z0)), Cons(S(S(z1)), Nil), Nil) -> c2(<'(S(S(z1)), S(S(z0)))) Defined Rule Symbols: !EQ_2, <_2, remove_2, remove[Ite][True][Ite]_3 Defined Pair Symbols: REMOVE_2, APPMIN_3, APPMIN[ITE][TRUE][ITE]_4, MINSORT_1, REMOVE[ITE][TRUE][ITE]_3, !EQ'_2, <'_2 Compound Symbols: c11, c16_2, c15_1, c16_1, c12, c9_1, c13_1, c11_1, c7_1, c10_1, c_1, c11_2, c1_1, c4_1, c15_2, c2_1