KILLED
proof of input_P2myjY1kZM.trs
# AProVE Commit ID: aff8ecad908e01718a4c36e68d2e55d5e0f16e15 fuhs 20220216 unpublished


The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).

(0) CpxTRS
(1) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxTRS
(3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(4) CpxTRS
(5) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(6) CpxWeightedTrs
    (7) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) CpxTypedWeightedTrs
    (9) CompletionProof [UPPER BOUND(ID), 0 ms]
    (10) CpxTypedWeightedCompleteTrs
        (11) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (12) CpxTypedWeightedCompleteTrs
        (13) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (14) CpxRNTS
        (15) SimplificationProof [BOTH BOUNDS(ID, ID), 16 ms]
        (16) CpxRNTS
        (17) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
        (18) CpxRNTS
        (19) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (20) CpxRNTS
        (21) IntTrsBoundProof [UPPER BOUND(ID), 334 ms]
        (22) CpxRNTS
        (23) IntTrsBoundProof [UPPER BOUND(ID), 150 ms]
        (24) CpxRNTS
        (25) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (26) CpxRNTS
        (27) IntTrsBoundProof [UPPER BOUND(ID), 367 ms]
        (28) CpxRNTS
        (29) IntTrsBoundProof [UPPER BOUND(ID), 147 ms]
        (30) CpxRNTS
        (31) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (32) CpxRNTS
        (33) IntTrsBoundProof [UPPER BOUND(ID), 112 ms]
        (34) CpxRNTS
        (35) IntTrsBoundProof [UPPER BOUND(ID), 4 ms]
        (36) CpxRNTS
        (37) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (38) CpxRNTS
        (39) IntTrsBoundProof [UPPER BOUND(ID), 138 ms]
        (40) CpxRNTS
        (41) IntTrsBoundProof [UPPER BOUND(ID), 22 ms]
        (42) CpxRNTS
        (43) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (44) CpxRNTS
        (45) IntTrsBoundProof [UPPER BOUND(ID), 139 ms]
        (46) CpxRNTS
        (47) IntTrsBoundProof [UPPER BOUND(ID), 43 ms]
        (48) CpxRNTS
        (49) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (50) CpxRNTS
        (51) IntTrsBoundProof [UPPER BOUND(ID), 182 ms]
        (52) CpxRNTS
        (53) IntTrsBoundProof [UPPER BOUND(ID), 15 ms]
        (54) CpxRNTS
        (55) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (56) CpxRNTS
        (57) IntTrsBoundProof [UPPER BOUND(ID), 5112 ms]
        (58) CpxRNTS
        (59) IntTrsBoundProof [UPPER BOUND(ID), 1420 ms]
        (60) CpxRNTS
    (61) CompletionProof [UPPER BOUND(ID), 0 ms]
    (62) CpxTypedWeightedCompleteTrs
        (63) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (64) CpxRNTS
(65) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(66) CdtProblem
    (67) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (68) CdtProblem
    (69) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (70) CdtProblem
    (71) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 190 ms]
    (72) CdtProblem
    (73) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 1963 ms]
    (74) CdtProblem
    (75) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (76) CdtProblem
    (77) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 1936 ms]
    (78) CdtProblem
    (79) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 2045 ms]
    (80) CdtProblem
    (81) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (82) CdtProblem
    (83) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (84) CdtProblem
    (85) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (86) CdtProblem
    (87) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (88) CdtProblem
    (89) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (90) CdtProblem
    (91) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (92) CdtProblem
    (93) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (94) CdtProblem
    (95) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (96) CdtProblem
    (97) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (98) CdtProblem
    (99) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (100) CdtProblem
    (101) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (102) CdtProblem
    (103) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (104) CdtProblem
    (105) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (106) CdtProblem
    (107) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (108) CdtProblem
    (109) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (110) CdtProblem
    (111) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (112) CdtProblem
    (113) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (114) CdtProblem
    (115) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (116) CdtProblem
    (117) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (118) CdtProblem
    (119) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (120) CdtProblem
    (121) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (122) CdtProblem
    (123) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (124) CdtProblem
    (125) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (126) CdtProblem
    (127) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (128) CdtProblem
    (129) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (130) CdtProblem
    (131) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (132) CdtProblem
    (133) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (134) CdtProblem
    (135) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (136) CdtProblem
    (137) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (138) CdtProblem
    (139) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (140) CdtProblem
    (141) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (142) CdtProblem
    (143) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (144) CdtProblem
    (145) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (146) CdtProblem
    (147) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (148) CdtProblem
    (149) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (150) CdtProblem
    (151) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (152) CdtProblem
    (153) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (154) CdtProblem
    (155) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 3 ms]
    (156) CdtProblem
    (157) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (158) CdtProblem
    (159) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (160) CdtProblem
    (161) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (162) CdtProblem
    (163) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (164) CdtProblem
    (165) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (166) CdtProblem
    (167) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (168) CdtProblem
    (169) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 3 ms]
    (170) CdtProblem
    (171) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (172) CdtProblem
    (173) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (174) CdtProblem
    (175) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (176) CdtProblem
    (177) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (178) CdtProblem
    (179) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (180) CdtProblem
    (181) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (182) CdtProblem
    (183) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (184) CdtProblem
    (185) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (186) CdtProblem
    (187) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (188) CdtProblem
    (189) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (190) CdtProblem
    (191) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (192) CdtProblem
    (193) CdtRewritingProof [BOTH BOUNDS(ID, ID), 5 ms]
    (194) CdtProblem
    (195) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (196) CdtProblem
    (197) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (198) CdtProblem
    (199) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (200) CdtProblem
    (201) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (202) CdtProblem
    (203) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (204) CdtProblem
    (205) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (206) CdtProblem
    (207) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (208) CdtProblem
    (209) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 108 ms]
    (210) CdtProblem
    (211) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (212) CdtProblem


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

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


The TRS R consists of the following rules:

   eq(0, 0) -> true
   eq(0, s(x)) -> false
   eq(s(x), 0) -> false
   eq(s(x), s(y)) -> eq(x, y)
   le(0, y) -> true
   le(s(x), 0) -> false
   le(s(x), s(y)) -> le(x, y)
   app(nil, y) -> y
   app(add(n, x), y) -> add(n, app(x, y))
   min(nil) -> 0
   min(add(n, x)) -> minIter(add(n, x), add(n, x), 0)
   minIter(nil, add(n, y), m) -> minIter(add(n, y), add(n, y), s(m))
   minIter(add(n, x), y, m) -> if_min(le(n, m), x, y, m)
   if_min(true, x, y, m) -> m
   if_min(false, x, y, m) -> minIter(x, y, m)
   head(add(n, x)) -> n
   tail(add(n, x)) -> x
   tail(nil) -> nil
   null(nil) -> true
   null(add(n, x)) -> false
   rm(n, nil) -> nil
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
   if_rm(true, n, add(m, x)) -> rm(n, x)
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
   minsort(nil, nil) -> nil
   minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
   if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
   if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

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

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

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


The TRS R consists of the following rules:

   eq(0', 0') -> true
   eq(0', s(x)) -> false
   eq(s(x), 0') -> false
   eq(s(x), s(y)) -> eq(x, y)
   le(0', y) -> true
   le(s(x), 0') -> false
   le(s(x), s(y)) -> le(x, y)
   app(nil, y) -> y
   app(add(n, x), y) -> add(n, app(x, y))
   min(nil) -> 0'
   min(add(n, x)) -> minIter(add(n, x), add(n, x), 0')
   minIter(nil, add(n, y), m) -> minIter(add(n, y), add(n, y), s(m))
   minIter(add(n, x), y, m) -> if_min(le(n, m), x, y, m)
   if_min(true, x, y, m) -> m
   if_min(false, x, y, m) -> minIter(x, y, m)
   head(add(n, x)) -> n
   tail(add(n, x)) -> x
   tail(nil) -> nil
   null(nil) -> true
   null(add(n, x)) -> false
   rm(n, nil) -> nil
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
   if_rm(true, n, add(m, x)) -> rm(n, x)
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
   minsort(nil, nil) -> nil
   minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
   if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
   if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

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

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

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


The TRS R consists of the following rules:

   eq(0, 0) -> true
   eq(0, s(x)) -> false
   eq(s(x), 0) -> false
   eq(s(x), s(y)) -> eq(x, y)
   le(0, y) -> true
   le(s(x), 0) -> false
   le(s(x), s(y)) -> le(x, y)
   app(nil, y) -> y
   app(add(n, x), y) -> add(n, app(x, y))
   min(nil) -> 0
   min(add(n, x)) -> minIter(add(n, x), add(n, x), 0)
   minIter(nil, add(n, y), m) -> minIter(add(n, y), add(n, y), s(m))
   minIter(add(n, x), y, m) -> if_min(le(n, m), x, y, m)
   if_min(true, x, y, m) -> m
   if_min(false, x, y, m) -> minIter(x, y, m)
   head(add(n, x)) -> n
   tail(add(n, x)) -> x
   tail(nil) -> nil
   null(nil) -> true
   null(add(n, x)) -> false
   rm(n, nil) -> nil
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
   if_rm(true, n, add(m, x)) -> rm(n, x)
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
   minsort(nil, nil) -> nil
   minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y)
   if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil))
   if_minsort(false, add(n, x), y) -> minsort(x, add(n, y))

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

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

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


The TRS R consists of the following rules:

   eq(0, 0) -> true [1]
   eq(0, s(x)) -> false [1]
   eq(s(x), 0) -> false [1]
   eq(s(x), s(y)) -> eq(x, y) [1]
   le(0, y) -> true [1]
   le(s(x), 0) -> false [1]
   le(s(x), s(y)) -> le(x, y) [1]
   app(nil, y) -> y [1]
   app(add(n, x), y) -> add(n, app(x, y)) [1]
   min(nil) -> 0 [1]
   min(add(n, x)) -> minIter(add(n, x), add(n, x), 0) [1]
   minIter(nil, add(n, y), m) -> minIter(add(n, y), add(n, y), s(m)) [1]
   minIter(add(n, x), y, m) -> if_min(le(n, m), x, y, m) [1]
   if_min(true, x, y, m) -> m [1]
   if_min(false, x, y, m) -> minIter(x, y, m) [1]
   head(add(n, x)) -> n [1]
   tail(add(n, x)) -> x [1]
   tail(nil) -> nil [1]
   null(nil) -> true [1]
   null(add(n, x)) -> false [1]
   rm(n, nil) -> nil [1]
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x)) [1]
   if_rm(true, n, add(m, x)) -> rm(n, x) [1]
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x)) [1]
   minsort(nil, nil) -> nil [1]
   minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y) [1]
   if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil)) [1]
   if_minsort(false, add(n, x), y) -> minsort(x, add(n, y)) [1]

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

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

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

   eq(0, 0) -> true [1]
   eq(0, s(x)) -> false [1]
   eq(s(x), 0) -> false [1]
   eq(s(x), s(y)) -> eq(x, y) [1]
   le(0, y) -> true [1]
   le(s(x), 0) -> false [1]
   le(s(x), s(y)) -> le(x, y) [1]
   app(nil, y) -> y [1]
   app(add(n, x), y) -> add(n, app(x, y)) [1]
   min(nil) -> 0 [1]
   min(add(n, x)) -> minIter(add(n, x), add(n, x), 0) [1]
   minIter(nil, add(n, y), m) -> minIter(add(n, y), add(n, y), s(m)) [1]
   minIter(add(n, x), y, m) -> if_min(le(n, m), x, y, m) [1]
   if_min(true, x, y, m) -> m [1]
   if_min(false, x, y, m) -> minIter(x, y, m) [1]
   head(add(n, x)) -> n [1]
   tail(add(n, x)) -> x [1]
   tail(nil) -> nil [1]
   null(nil) -> true [1]
   null(add(n, x)) -> false [1]
   rm(n, nil) -> nil [1]
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x)) [1]
   if_rm(true, n, add(m, x)) -> rm(n, x) [1]
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x)) [1]
   minsort(nil, nil) -> nil [1]
   minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y) [1]
   if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil)) [1]
   if_minsort(false, add(n, x), y) -> minsort(x, add(n, y)) [1]

The TRS has the following type information:
eq :: 0:s -> 0:s -> true:false
0 :: 0:s
true :: true:false
s :: 0:s -> 0:s
false :: true:false
le :: 0:s -> 0:s -> true:false
app :: nil:add -> nil:add -> nil:add
nil :: nil:add
add :: 0:s -> nil:add -> nil:add
min :: nil:add -> 0:s
minIter :: nil:add -> nil:add -> 0:s -> 0:s
if_min :: true:false -> nil:add -> nil:add -> 0:s -> 0:s
head :: nil:add -> 0:s
tail :: nil:add -> nil:add
null :: nil:add -> true:false
rm :: 0:s -> nil:add -> nil:add
if_rm :: true:false -> 0:s -> nil:add -> nil:add
minsort :: nil:add -> nil:add -> nil:add
if_minsort :: true:false -> nil:add -> nil:add -> nil:add

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

(9) CompletionProof (UPPER BOUND(ID))
The transformation into a RNTS is sound, since:

(a) The obligation is a constructor system where every type has a constant constructor,

(b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols:

   head_1
   tail_1
   null_1
   minsort_2
   if_minsort_3

(c) The following functions are completely defined:

   app_2
   rm_2
   le_2
   eq_2
   min_1
   minIter_3
   if_rm_3
   if_min_4

Due to the following rules being added:

   minIter(v0, v1, v2) -> 0 [0]
   if_rm(v0, v1, v2) -> nil [0]

And the following fresh constants: none

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

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

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

   eq(0, 0) -> true [1]
   eq(0, s(x)) -> false [1]
   eq(s(x), 0) -> false [1]
   eq(s(x), s(y)) -> eq(x, y) [1]
   le(0, y) -> true [1]
   le(s(x), 0) -> false [1]
   le(s(x), s(y)) -> le(x, y) [1]
   app(nil, y) -> y [1]
   app(add(n, x), y) -> add(n, app(x, y)) [1]
   min(nil) -> 0 [1]
   min(add(n, x)) -> minIter(add(n, x), add(n, x), 0) [1]
   minIter(nil, add(n, y), m) -> minIter(add(n, y), add(n, y), s(m)) [1]
   minIter(add(n, x), y, m) -> if_min(le(n, m), x, y, m) [1]
   if_min(true, x, y, m) -> m [1]
   if_min(false, x, y, m) -> minIter(x, y, m) [1]
   head(add(n, x)) -> n [1]
   tail(add(n, x)) -> x [1]
   tail(nil) -> nil [1]
   null(nil) -> true [1]
   null(add(n, x)) -> false [1]
   rm(n, nil) -> nil [1]
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x)) [1]
   if_rm(true, n, add(m, x)) -> rm(n, x) [1]
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x)) [1]
   minsort(nil, nil) -> nil [1]
   minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y) [1]
   if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil)) [1]
   if_minsort(false, add(n, x), y) -> minsort(x, add(n, y)) [1]
   minIter(v0, v1, v2) -> 0 [0]
   if_rm(v0, v1, v2) -> nil [0]

The TRS has the following type information:
eq :: 0:s -> 0:s -> true:false
0 :: 0:s
true :: true:false
s :: 0:s -> 0:s
false :: true:false
le :: 0:s -> 0:s -> true:false
app :: nil:add -> nil:add -> nil:add
nil :: nil:add
add :: 0:s -> nil:add -> nil:add
min :: nil:add -> 0:s
minIter :: nil:add -> nil:add -> 0:s -> 0:s
if_min :: true:false -> nil:add -> nil:add -> 0:s -> 0:s
head :: nil:add -> 0:s
tail :: nil:add -> nil:add
null :: nil:add -> true:false
rm :: 0:s -> nil:add -> nil:add
if_rm :: true:false -> 0:s -> nil:add -> nil:add
minsort :: nil:add -> nil:add -> nil:add
if_minsort :: true:false -> nil:add -> nil:add -> nil:add

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

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

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

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

   eq(0, 0) -> true [1]
   eq(0, s(x)) -> false [1]
   eq(s(x), 0) -> false [1]
   eq(s(x), s(y)) -> eq(x, y) [1]
   le(0, y) -> true [1]
   le(s(x), 0) -> false [1]
   le(s(x), s(y)) -> le(x, y) [1]
   app(nil, y) -> y [1]
   app(add(n, x), y) -> add(n, app(x, y)) [1]
   min(nil) -> 0 [1]
   min(add(n, x)) -> minIter(add(n, x), add(n, x), 0) [1]
   minIter(nil, add(n, y), m) -> minIter(add(n, y), add(n, y), s(m)) [1]
   minIter(add(0, x), y, m) -> if_min(true, x, y, m) [2]
   minIter(add(s(x'), x), y, 0) -> if_min(false, x, y, 0) [2]
   minIter(add(s(x''), x), y, s(y')) -> if_min(le(x'', y'), x, y, s(y')) [2]
   if_min(true, x, y, m) -> m [1]
   if_min(false, x, y, m) -> minIter(x, y, m) [1]
   head(add(n, x)) -> n [1]
   tail(add(n, x)) -> x [1]
   tail(nil) -> nil [1]
   null(nil) -> true [1]
   null(add(n, x)) -> false [1]
   rm(n, nil) -> nil [1]
   rm(0, add(0, x)) -> if_rm(true, 0, add(0, x)) [2]
   rm(0, add(s(x1), x)) -> if_rm(false, 0, add(s(x1), x)) [2]
   rm(s(x2), add(0, x)) -> if_rm(false, s(x2), add(0, x)) [2]
   rm(s(x3), add(s(y''), x)) -> if_rm(eq(x3, y''), s(x3), add(s(y''), x)) [2]
   if_rm(true, n, add(m, x)) -> rm(n, x) [1]
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x)) [1]
   minsort(nil, nil) -> nil [1]
   minsort(add(n, x), y) -> if_minsort(eq(n, minIter(add(n, x), add(n, x), 0)), add(n, x), y) [2]
   if_minsort(true, add(n, nil), y) -> add(n, minsort(app(nil, y), nil)) [2]
   if_minsort(true, add(n, add(m', x4)), y) -> add(n, minsort(app(if_rm(eq(n, m'), n, add(m', x4)), y), nil)) [2]
   if_minsort(false, add(n, x), y) -> minsort(x, add(n, y)) [1]
   minIter(v0, v1, v2) -> 0 [0]
   if_rm(v0, v1, v2) -> nil [0]

The TRS has the following type information:
eq :: 0:s -> 0:s -> true:false
0 :: 0:s
true :: true:false
s :: 0:s -> 0:s
false :: true:false
le :: 0:s -> 0:s -> true:false
app :: nil:add -> nil:add -> nil:add
nil :: nil:add
add :: 0:s -> nil:add -> nil:add
min :: nil:add -> 0:s
minIter :: nil:add -> nil:add -> 0:s -> 0:s
if_min :: true:false -> nil:add -> nil:add -> 0:s -> 0:s
head :: nil:add -> 0:s
tail :: nil:add -> nil:add
null :: nil:add -> true:false
rm :: 0:s -> nil:add -> nil:add
if_rm :: true:false -> 0:s -> nil:add -> nil:add
minsort :: nil:add -> nil:add -> nil:add
if_minsort :: true:false -> nil:add -> nil:add -> nil:add

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

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

   0 => 0
   true => 1
   false => 0
   nil => 0

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

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

   app(z, z') -{ 1 }-> y :|: y >= 0, z = 0, z' = y
   app(z, z') -{ 1 }-> 1 + n + app(x, y) :|: n >= 0, x >= 0, y >= 0, z = 1 + n + x, z' = y
   eq(z, z') -{ 1 }-> eq(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' = 1 + x, x >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: x >= 0, z = 1 + x, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> m :|: z' = x, z'' = y, z = 1, z1 = m, x >= 0, y >= 0, m >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(x, y, m) :|: z' = x, z'' = y, z1 = m, x >= 0, y >= 0, z = 0, m >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + y) :|: n >= 0, z'' = y, z' = 1 + n + x, x >= 0, y >= 0, z = 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + n + minsort(app(if_rm(eq(n, m'), n, 1 + m' + x4), y), 0) :|: n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z'' = y, z = 1, y >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + n + minsort(app(0, y), 0) :|: n >= 0, z'' = y, z = 1, y >= 0, z' = 1 + n + 0
   if_rm(z, z', z'') -{ 1 }-> rm(n, x) :|: n >= 0, z = 1, z'' = 1 + m + x, x >= 0, z' = n, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(n, x) :|: n >= 0, z'' = 1 + m + x, x >= 0, z' = n, z = 0, m >= 0
   le(z, z') -{ 1 }-> le(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   le(z, z') -{ 1 }-> 1 :|: y >= 0, z = 0, z' = y
   le(z, z') -{ 1 }-> 0 :|: x >= 0, z = 1 + x, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + m) :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' = m, m >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(le(x'', y'), x, y, 1 + y') :|: x >= 0, y >= 0, y' >= 0, z = 1 + (1 + x'') + x, x'' >= 0, z' = y, z'' = 1 + y'
   minIter(z, z', z'') -{ 2 }-> if_min(1, x, y, m) :|: x >= 0, y >= 0, z = 1 + 0 + x, z' = y, z'' = m, m >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, y, 0) :|: z'' = 0, x' >= 0, x >= 0, y >= 0, z = 1 + (1 + x') + x, z' = y
   minIter(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, y) :|: n >= 0, x >= 0, y >= 0, z = 1 + n + x, z' = y
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 2 }-> if_rm(eq(x3, y''), 1 + x3, 1 + (1 + y'') + x) :|: x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z = 1 + x3, x3 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + x) :|: x >= 0, z' = 1 + 0 + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + x2, 1 + 0 + x) :|: x >= 0, z = 1 + x2, z' = 1 + 0 + x, x2 >= 0
   rm(z, z') -{ 1 }-> 0 :|: n >= 0, z = n, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0


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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + n + minsort(app(if_rm(eq(n, m'), n, 1 + m' + x4), z''), 0) :|: n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 1 }-> le(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(le(x'', z'' - 1), x, z', 1 + (z'' - 1)) :|: x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 2 }-> if_rm(eq(z - 1, y''), 1 + (z - 1), 1 + (1 + y'') + x) :|: x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0


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

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

   { le }
   { eq }
   { tail }
   { head }
   { null }
   { app }
   { minIter, if_min }
   { if_rm, rm }
   { min }
   { minsort, if_minsort }

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + n + minsort(app(if_rm(eq(n, m'), n, 1 + m' + x4), z''), 0) :|: n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 1 }-> le(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(le(x'', z'' - 1), x, z', 1 + (z'' - 1)) :|: x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 2 }-> if_rm(eq(z - 1, y''), 1 + (z - 1), 1 + (1 + y'') + x) :|: x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {le}, {eq}, {tail}, {head}, {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + n + minsort(app(if_rm(eq(n, m'), n, 1 + m' + x4), z''), 0) :|: n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 1 }-> le(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(le(x'', z'' - 1), x, z', 1 + (z'' - 1)) :|: x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 2 }-> if_rm(eq(z - 1, y''), 1 + (z - 1), 1 + (1 + y'') + x) :|: x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {le}, {eq}, {tail}, {head}, {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}

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

(21) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + n + minsort(app(if_rm(eq(n, m'), n, 1 + m' + x4), z''), 0) :|: n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 1 }-> le(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(le(x'', z'' - 1), x, z', 1 + (z'' - 1)) :|: x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 2 }-> if_rm(eq(z - 1, y''), 1 + (z - 1), 1 + (1 + y'') + x) :|: x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {le}, {eq}, {tail}, {head}, {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: ?, size: O(1) [1]

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

(23) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + n + minsort(app(if_rm(eq(n, m'), n, 1 + m' + x4), z''), 0) :|: n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 1 }-> le(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(le(x'', z'' - 1), x, z', 1 + (z'' - 1)) :|: x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 2 }-> if_rm(eq(z - 1, y''), 1 + (z - 1), 1 + (1 + y'') + x) :|: x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {eq}, {tail}, {head}, {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + n + minsort(app(if_rm(eq(n, m'), n, 1 + m' + x4), z''), 0) :|: n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 2 }-> if_rm(eq(z - 1, y''), 1 + (z - 1), 1 + (1 + y'') + x) :|: x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {eq}, {tail}, {head}, {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]

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

(27) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + n + minsort(app(if_rm(eq(n, m'), n, 1 + m' + x4), z''), 0) :|: n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 2 }-> if_rm(eq(z - 1, y''), 1 + (z - 1), 1 + (1 + y'') + x) :|: x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {eq}, {tail}, {head}, {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: ?, size: O(1) [1]

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

(29) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 1 }-> eq(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + n + minsort(app(if_rm(eq(n, m'), n, 1 + m' + x4), z''), 0) :|: n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 2 }-> if_rm(eq(z - 1, y''), 1 + (z - 1), 1 + (1 + y'') + x) :|: x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {tail}, {head}, {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {tail}, {head}, {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]

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

(33) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: tail
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: z

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {tail}, {head}, {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: ?, size: O(n^1) [z]

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

(35) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {head}, {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {head}, {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: head
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: z

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {head}, {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]
  head: runtime: ?, size: O(n^1) [z]

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

(41) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]
  head: runtime: O(1) [1], size: O(n^1) [z]

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]
  head: runtime: O(1) [1], size: O(n^1) [z]

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {null}, {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  null: runtime: ?, size: O(1) [1]

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

(47) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  null: runtime: O(1) [1], size: O(1) [1]

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  null: runtime: O(1) [1], size: O(1) [1]

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {app}, {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: ?, size: O(n^1) [z + z']

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

(53) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 1 }-> 1 + n + app(x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 2 }-> 1 + (z' - 1) + minsort(app(0, z''), 0) :|: z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z], size: O(n^1) [z + z']

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

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 2 + x }-> 1 + n + s3 :|: s3 >= 0, s3 <= x + z', n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 3 }-> 1 + (z' - 1) + minsort(s4, 0) :|: s4 >= 0, s4 <= 0 + z'', z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z], size: O(n^1) [z + z']

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: minIter
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

Computed SIZE bound using CoFloCo for: if_min
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 2 + x }-> 1 + n + s3 :|: s3 >= 0, s3 <= x + z', n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 3 }-> 1 + (z' - 1) + minsort(s4, 0) :|: s4 >= 0, s4 <= 0 + z'', z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z], size: O(n^1) [z + z']
  minIter: runtime: ?, size: INF
  if_min: runtime: ?, size: INF

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

(59) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: minIter
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

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

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

   app(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   app(z, z') -{ 2 + x }-> 1 + n + s3 :|: s3 >= 0, s3 <= x + z', n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   eq(z, z') -{ 3 + z' }-> s'' :|: s'' >= 0, s'' <= 1, z - 1 >= 0, z' - 1 >= 0
   eq(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0
   eq(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   if_min(z, z', z'', z1) -{ 1 }-> z1 :|: z = 1, z' >= 0, z'' >= 0, z1 >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(z', z'', z1) :|: z' >= 0, z'' >= 0, z = 0, z1 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0, z = 0
   if_minsort(z, z', z'') -{ 5 + m' }-> 1 + n + minsort(app(if_rm(s2, n, 1 + m' + x4), z''), 0) :|: s2 >= 0, s2 <= 1, n >= 0, x4 >= 0, z' = 1 + n + (1 + m' + x4), z = 1, z'' >= 0, m' >= 0
   if_minsort(z, z', z'') -{ 3 }-> 1 + (z' - 1) + minsort(s4, 0) :|: s4 >= 0, s4 <= 0 + z'', z' - 1 >= 0, z = 1, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(z', x) :|: z' >= 0, z = 1, z'' = 1 + m + x, x >= 0, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(z', x) :|: z' >= 0, z'' = 1 + m + x, x >= 0, z = 0, m >= 0
   le(z, z') -{ 2 + z' }-> s :|: s >= 0, s <= 1, z - 1 >= 0, z' - 1 >= 0
   le(z, z') -{ 1 }-> 1 :|: z' >= 0, z = 0
   le(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + z'') :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' >= 0
   minIter(z, z', z'') -{ 3 + z'' }-> if_min(s', x, z', 1 + (z'' - 1)) :|: s' >= 0, s' <= 1, x >= 0, z' >= 0, z'' - 1 >= 0, z = 1 + (1 + x'') + x, x'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(1, z - 1, z', z'') :|: z - 1 >= 0, z' >= 0, z'' >= 0
   minIter(z, z', z'') -{ 2 }-> if_min(0, x, z', 0) :|: z'' = 0, x' >= 0, x >= 0, z' >= 0, z = 1 + (1 + x') + x
   minIter(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   minsort(z, z') -{ 2 }-> if_minsort(eq(n, minIter(1 + n + x, 1 + n + x, 0)), 1 + n + x, z') :|: n >= 0, x >= 0, z' >= 0, z = 1 + n + x
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   null(z) -{ 1 }-> 1 :|: z = 0
   null(z) -{ 1 }-> 0 :|: n >= 0, x >= 0, z = 1 + n + x
   rm(z, z') -{ 5 + y'' }-> if_rm(s1, 1 + (z - 1), 1 + (1 + y'') + x) :|: s1 >= 0, s1 <= 1, x >= 0, y'' >= 0, z' = 1 + (1 + y'') + x, z - 1 >= 0
   rm(z, z') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 1 + (1 + x1) + x, z = 0
   rm(z, z') -{ 2 }-> if_rm(0, 1 + (z - 1), 1 + 0 + (z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   rm(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0

Function symbols to be analyzed: {minIter,if_min}, {if_rm,rm}, {min}, {minsort,if_minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z'], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z]
  head: runtime: O(1) [1], size: O(n^1) [z]
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z], size: O(n^1) [z + z']
  minIter: runtime: INF, size: INF
  if_min: runtime: ?, size: INF

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

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

   minIter(v0, v1, v2) -> null_minIter [0]
   head(v0) -> null_head [0]
   if_rm(v0, v1, v2) -> null_if_rm [0]
   minsort(v0, v1) -> null_minsort [0]
   if_minsort(v0, v1, v2) -> null_if_minsort [0]
   eq(v0, v1) -> null_eq [0]
   le(v0, v1) -> null_le [0]
   app(v0, v1) -> null_app [0]
   min(v0) -> null_min [0]
   tail(v0) -> null_tail [0]
   null(v0) -> null_null [0]
   rm(v0, v1) -> null_rm [0]
   if_min(v0, v1, v2, v3) -> null_if_min [0]

And the following fresh constants:    null_minIter, null_head, null_if_rm, null_minsort, null_if_minsort, null_eq, null_le, null_app, null_min, null_tail, null_null, null_rm, null_if_min

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

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

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

   eq(0, 0) -> true [1]
   eq(0, s(x)) -> false [1]
   eq(s(x), 0) -> false [1]
   eq(s(x), s(y)) -> eq(x, y) [1]
   le(0, y) -> true [1]
   le(s(x), 0) -> false [1]
   le(s(x), s(y)) -> le(x, y) [1]
   app(nil, y) -> y [1]
   app(add(n, x), y) -> add(n, app(x, y)) [1]
   min(nil) -> 0 [1]
   min(add(n, x)) -> minIter(add(n, x), add(n, x), 0) [1]
   minIter(nil, add(n, y), m) -> minIter(add(n, y), add(n, y), s(m)) [1]
   minIter(add(n, x), y, m) -> if_min(le(n, m), x, y, m) [1]
   if_min(true, x, y, m) -> m [1]
   if_min(false, x, y, m) -> minIter(x, y, m) [1]
   head(add(n, x)) -> n [1]
   tail(add(n, x)) -> x [1]
   tail(nil) -> nil [1]
   null(nil) -> true [1]
   null(add(n, x)) -> false [1]
   rm(n, nil) -> nil [1]
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x)) [1]
   if_rm(true, n, add(m, x)) -> rm(n, x) [1]
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x)) [1]
   minsort(nil, nil) -> nil [1]
   minsort(add(n, x), y) -> if_minsort(eq(n, min(add(n, x))), add(n, x), y) [1]
   if_minsort(true, add(n, x), y) -> add(n, minsort(app(rm(n, x), y), nil)) [1]
   if_minsort(false, add(n, x), y) -> minsort(x, add(n, y)) [1]
   minIter(v0, v1, v2) -> null_minIter [0]
   head(v0) -> null_head [0]
   if_rm(v0, v1, v2) -> null_if_rm [0]
   minsort(v0, v1) -> null_minsort [0]
   if_minsort(v0, v1, v2) -> null_if_minsort [0]
   eq(v0, v1) -> null_eq [0]
   le(v0, v1) -> null_le [0]
   app(v0, v1) -> null_app [0]
   min(v0) -> null_min [0]
   tail(v0) -> null_tail [0]
   null(v0) -> null_null [0]
   rm(v0, v1) -> null_rm [0]
   if_min(v0, v1, v2, v3) -> null_if_min [0]

The TRS has the following type information:
eq :: 0:s:null_minIter:null_head:null_min:null_if_min -> 0:s:null_minIter:null_head:null_min:null_if_min -> true:false:null_eq:null_le:null_null
0 :: 0:s:null_minIter:null_head:null_min:null_if_min
true :: true:false:null_eq:null_le:null_null
s :: 0:s:null_minIter:null_head:null_min:null_if_min -> 0:s:null_minIter:null_head:null_min:null_if_min
false :: true:false:null_eq:null_le:null_null
le :: 0:s:null_minIter:null_head:null_min:null_if_min -> 0:s:null_minIter:null_head:null_min:null_if_min -> true:false:null_eq:null_le:null_null
app :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
nil :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
add :: 0:s:null_minIter:null_head:null_min:null_if_min -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
min :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> 0:s:null_minIter:null_head:null_min:null_if_min
minIter :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> 0:s:null_minIter:null_head:null_min:null_if_min -> 0:s:null_minIter:null_head:null_min:null_if_min
if_min :: true:false:null_eq:null_le:null_null -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> 0:s:null_minIter:null_head:null_min:null_if_min -> 0:s:null_minIter:null_head:null_min:null_if_min
head :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> 0:s:null_minIter:null_head:null_min:null_if_min
tail :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
null :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> true:false:null_eq:null_le:null_null
rm :: 0:s:null_minIter:null_head:null_min:null_if_min -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
if_rm :: true:false:null_eq:null_le:null_null -> 0:s:null_minIter:null_head:null_min:null_if_min -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
minsort :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
if_minsort :: true:false:null_eq:null_le:null_null -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm -> nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
null_minIter :: 0:s:null_minIter:null_head:null_min:null_if_min
null_head :: 0:s:null_minIter:null_head:null_min:null_if_min
null_if_rm :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
null_minsort :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
null_if_minsort :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
null_eq :: true:false:null_eq:null_le:null_null
null_le :: true:false:null_eq:null_le:null_null
null_app :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
null_min :: 0:s:null_minIter:null_head:null_min:null_if_min
null_tail :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
null_null :: true:false:null_eq:null_le:null_null
null_rm :: nil:add:null_if_rm:null_minsort:null_if_minsort:null_app:null_tail:null_rm
null_if_min :: 0:s:null_minIter:null_head:null_min:null_if_min

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

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

   0 => 0
   true => 2
   false => 1
   nil => 0
   null_minIter => 0
   null_head => 0
   null_if_rm => 0
   null_minsort => 0
   null_if_minsort => 0
   null_eq => 0
   null_le => 0
   null_app => 0
   null_min => 0
   null_tail => 0
   null_null => 0
   null_rm => 0
   null_if_min => 0

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

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

   app(z, z') -{ 1 }-> y :|: y >= 0, z = 0, z' = y
   app(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   app(z, z') -{ 1 }-> 1 + n + app(x, y) :|: n >= 0, x >= 0, y >= 0, z = 1 + n + x, z' = y
   eq(z, z') -{ 1 }-> eq(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   eq(z, z') -{ 1 }-> 2 :|: z = 0, z' = 0
   eq(z, z') -{ 1 }-> 1 :|: z' = 1 + x, x >= 0, z = 0
   eq(z, z') -{ 1 }-> 1 :|: x >= 0, z = 1 + x, z' = 0
   eq(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   head(z) -{ 1 }-> n :|: n >= 0, x >= 0, z = 1 + n + x
   head(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   if_min(z, z', z'', z1) -{ 1 }-> m :|: z = 2, z' = x, z'' = y, z1 = m, x >= 0, y >= 0, m >= 0
   if_min(z, z', z'', z1) -{ 1 }-> minIter(x, y, m) :|: z' = x, z'' = y, z = 1, z1 = m, x >= 0, y >= 0, m >= 0
   if_min(z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   if_minsort(z, z', z'') -{ 1 }-> minsort(x, 1 + n + y) :|: n >= 0, z'' = y, z = 1, z' = 1 + n + x, x >= 0, y >= 0
   if_minsort(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   if_minsort(z, z', z'') -{ 1 }-> 1 + n + minsort(app(rm(n, x), y), 0) :|: z = 2, n >= 0, z'' = y, z' = 1 + n + x, x >= 0, y >= 0
   if_rm(z, z', z'') -{ 1 }-> rm(n, x) :|: z = 2, n >= 0, z'' = 1 + m + x, x >= 0, z' = n, m >= 0
   if_rm(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   if_rm(z, z', z'') -{ 1 }-> 1 + m + rm(n, x) :|: n >= 0, z = 1, z'' = 1 + m + x, x >= 0, z' = n, m >= 0
   le(z, z') -{ 1 }-> le(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   le(z, z') -{ 1 }-> 2 :|: y >= 0, z = 0, z' = y
   le(z, z') -{ 1 }-> 1 :|: x >= 0, z = 1 + x, z' = 0
   le(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   min(z) -{ 1 }-> minIter(1 + n + x, 1 + n + x, 0) :|: n >= 0, x >= 0, z = 1 + n + x
   min(z) -{ 1 }-> 0 :|: z = 0
   min(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   minIter(z, z', z'') -{ 1 }-> minIter(1 + n + y, 1 + n + y, 1 + m) :|: n >= 0, z' = 1 + n + y, y >= 0, z = 0, z'' = m, m >= 0
   minIter(z, z', z'') -{ 1 }-> if_min(le(n, m), x, y, m) :|: n >= 0, x >= 0, y >= 0, z = 1 + n + x, z' = y, z'' = m, m >= 0
   minIter(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   minsort(z, z') -{ 1 }-> if_minsort(eq(n, min(1 + n + x)), 1 + n + x, y) :|: n >= 0, x >= 0, y >= 0, z = 1 + n + x, z' = y
   minsort(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0
   minsort(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   null(z) -{ 1 }-> 2 :|: z = 0
   null(z) -{ 1 }-> 1 :|: n >= 0, x >= 0, z = 1 + n + x
   null(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   rm(z, z') -{ 1 }-> if_rm(eq(n, m), n, 1 + m + x) :|: n >= 0, z' = 1 + m + x, z = n, x >= 0, m >= 0
   rm(z, z') -{ 1 }-> 0 :|: n >= 0, z = n, z' = 0
   rm(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   tail(z) -{ 1 }-> x :|: n >= 0, x >= 0, z = 1 + n + x
   tail(z) -{ 1 }-> 0 :|: z = 0
   tail(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0

Only complete derivations are relevant for the runtime complexity.

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

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

(66)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   min(nil) -> 0
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   head(add(z0, z1)) -> z0
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   null(nil) -> true
   null(add(z0, z1)) -> false
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   minsort(nil, nil) -> nil
   minsort(add(z0, z1), z2) -> if_minsort(eq(z0, min(add(z0, z1))), add(z0, z1), z2)
   if_minsort(true, add(z0, z1), z2) -> add(z0, minsort(app(rm(z0, z1), z2), nil))
   if_minsort(false, add(z0, z1), z2) -> minsort(z1, add(z0, z2))
Tuples:
   EQ(0, 0) -> c
   EQ(0, s(z0)) -> c1
   EQ(s(z0), 0) -> c2
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(0, z0) -> c4
   LE(s(z0), 0) -> c5
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(nil, z0) -> c7
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(nil) -> c9
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(true, z0, z1, z2) -> c13
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   HEAD(add(z0, z1)) -> c15
   TAIL(add(z0, z1)) -> c16
   TAIL(nil) -> c17
   NULL(nil) -> c18
   NULL(add(z0, z1)) -> c19
   RM(z0, nil) -> c20
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(nil, nil) -> c24
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
S tuples:
   EQ(0, 0) -> c
   EQ(0, s(z0)) -> c1
   EQ(s(z0), 0) -> c2
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(0, z0) -> c4
   LE(s(z0), 0) -> c5
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(nil, z0) -> c7
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(nil) -> c9
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(true, z0, z1, z2) -> c13
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   HEAD(add(z0, z1)) -> c15
   TAIL(add(z0, z1)) -> c16
   TAIL(nil) -> c17
   NULL(nil) -> c18
   NULL(add(z0, z1)) -> c19
   RM(z0, nil) -> c20
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(nil, nil) -> c24
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
K tuples:none
Defined Rule Symbols:   eq_2, le_2, app_2, min_1, minIter_3, if_min_4, head_1, tail_1, null_1, rm_2, if_rm_3, minsort_2, if_minsort_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, HEAD_1, TAIL_1, NULL_1, RM_2, IF_RM_3, MINSORT_2, IF_MINSORT_3

Compound Symbols:   c, c1, c2, c3_1, c4, c5, c6_1, c7, c8_1, c9, c10_1, c11_1, c12_2, c13, c14_1, c15, c16, c17, c18, c19, c20, c21_2, c22_1, c23_1, c24, c25_3, c26_3, c27_1


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

(67) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 15 trailing nodes:
   HEAD(add(z0, z1)) -> c15
   APP(nil, z0) -> c7
   LE(0, z0) -> c4
   TAIL(add(z0, z1)) -> c16
   EQ(0, 0) -> c
   TAIL(nil) -> c17
   LE(s(z0), 0) -> c5
   MINSORT(nil, nil) -> c24
   EQ(s(z0), 0) -> c2
   EQ(0, s(z0)) -> c1
   NULL(nil) -> c18
   IF_MIN(true, z0, z1, z2) -> c13
   RM(z0, nil) -> c20
   MIN(nil) -> c9
   NULL(add(z0, z1)) -> c19

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

(68)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   min(nil) -> 0
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   head(add(z0, z1)) -> z0
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   null(nil) -> true
   null(add(z0, z1)) -> false
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   minsort(nil, nil) -> nil
   minsort(add(z0, z1), z2) -> if_minsort(eq(z0, min(add(z0, z1))), add(z0, z1), z2)
   if_minsort(true, add(z0, z1), z2) -> add(z0, minsort(app(rm(z0, z1), z2), nil))
   if_minsort(false, add(z0, z1), z2) -> minsort(z1, add(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
K tuples:none
Defined Rule Symbols:   eq_2, le_2, app_2, min_1, minIter_3, if_min_4, head_1, tail_1, null_1, rm_2, if_rm_3, minsort_2, if_minsort_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, RM_2, IF_RM_3, MINSORT_2, IF_MINSORT_3

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c12_2, c14_1, c21_2, c22_1, c23_1, c25_3, c26_3, c27_1


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

(69) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   min(nil) -> 0
   head(add(z0, z1)) -> z0
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   null(nil) -> true
   null(add(z0, z1)) -> false
   minsort(nil, nil) -> nil
   minsort(add(z0, z1), z2) -> if_minsort(eq(z0, min(add(z0, z1))), add(z0, z1), z2)
   if_minsort(true, add(z0, z1), z2) -> add(z0, minsort(app(rm(z0, z1), z2), nil))
   if_minsort(false, add(z0, z1), z2) -> minsort(z1, add(z0, z2))

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

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
K tuples:none
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, RM_2, IF_RM_3, MINSORT_2, IF_MINSORT_3

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c12_2, c14_1, c21_2, c22_1, c23_1, c25_3, c26_3, c27_1


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

(71) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   app(nil, z0) -> z0
   rm(z0, nil) -> nil
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF_MIN(x_1, x_2, x_3, x_4)) = 0
   POL(IF_MINSORT(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(IF_RM(x_1, x_2, x_3)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = 0
   POL(MINITER(x_1, x_2, x_3)) = 0
   POL(MINSORT(x_1, x_2)) = [1] + x_1 + x_2
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = [1] + x_2
   POL(app(x_1, x_2)) = x_1 + x_2
   POL(c10(x_1)) = x_1
   POL(c11(x_1)) = x_1
   POL(c12(x_1, x_2)) = x_1 + x_2
   POL(c14(x_1)) = x_1
   POL(c21(x_1, x_2)) = x_1 + x_2
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = x_1
   POL(false) = 0
   POL(if_min(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4
   POL(if_rm(x_1, x_2, x_3)) = x_3
   POL(le(x_1, x_2)) = [1] + x_1 + x_2
   POL(min(x_1)) = [1]
   POL(minIter(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3
   POL(nil) = 0
   POL(rm(x_1, x_2)) = x_2
   POL(s(x_1)) = [1] + x_1
   POL(true) = 0

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

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, RM_2, IF_RM_3, MINSORT_2, IF_MINSORT_3

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c12_2, c14_1, c21_2, c22_1, c23_1, c25_3, c26_3, c27_1


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

(73) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   app(nil, z0) -> z0
   rm(z0, nil) -> nil
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = x_2
   POL(EQ(x_1, x_2)) = 0
   POL(IF_MIN(x_1, x_2, x_3, x_4)) = 0
   POL(IF_MINSORT(x_1, x_2, x_3)) = x_2 + x_3^2 + [2]x_2*x_3 + x_2^2
   POL(IF_RM(x_1, x_2, x_3)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = 0
   POL(MINITER(x_1, x_2, x_3)) = 0
   POL(MINSORT(x_1, x_2)) = [1] + x_1 + x_2^2 + [2]x_1*x_2 + x_1^2
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = [2] + x_2
   POL(app(x_1, x_2)) = x_1 + x_2
   POL(c10(x_1)) = x_1
   POL(c11(x_1)) = x_1
   POL(c12(x_1, x_2)) = x_1 + x_2
   POL(c14(x_1)) = x_1
   POL(c21(x_1, x_2)) = x_1 + x_2
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(if_min(x_1, x_2, x_3, x_4)) = [1] + [2]x_2 + x_3 + x_4 + x_4^2 + x_3*x_4 + x_2*x_4 + x_3^2 + [2]x_2*x_3 + [2]x_2^2
   POL(if_rm(x_1, x_2, x_3)) = x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = 0
   POL(minIter(x_1, x_2, x_3)) = [1] + [2]x_1^2 + [2]x_1*x_2
   POL(nil) = 0
   POL(rm(x_1, x_2)) = x_2
   POL(s(x_1)) = 0
   POL(true) = 0

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

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, RM_2, IF_RM_3, MINSORT_2, IF_MINSORT_3

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c12_2, c14_1, c21_2, c22_1, c23_1, c25_3, c26_3, c27_1


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

(75) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))

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

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, RM_2, IF_RM_3, MINSORT_2, IF_MINSORT_3

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c12_2, c14_1, c21_2, c22_1, c23_1, c25_3, c26_3, c27_1


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

(77) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   app(nil, z0) -> z0
   rm(z0, nil) -> nil
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = x_1
   POL(EQ(x_1, x_2)) = 0
   POL(IF_MIN(x_1, x_2, x_3, x_4)) = 0
   POL(IF_MINSORT(x_1, x_2, x_3)) = x_3^2 + [2]x_2*x_3 + x_2^2
   POL(IF_RM(x_1, x_2, x_3)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = 0
   POL(MINITER(x_1, x_2, x_3)) = 0
   POL(MINSORT(x_1, x_2)) = x_2^2 + [2]x_1*x_2 + x_1^2
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = [1] + x_2
   POL(app(x_1, x_2)) = x_1 + x_2
   POL(c10(x_1)) = x_1
   POL(c11(x_1)) = x_1
   POL(c12(x_1, x_2)) = x_1 + x_2
   POL(c14(x_1)) = x_1
   POL(c21(x_1, x_2)) = x_1 + x_2
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(if_min(x_1, x_2, x_3, x_4)) = [1] + [2]x_2 + x_3 + x_4 + x_4^2 + x_3*x_4 + x_2*x_4 + x_3^2 + [2]x_2*x_3 + x_2^2
   POL(if_rm(x_1, x_2, x_3)) = x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = 0
   POL(minIter(x_1, x_2, x_3)) = [1] + [2]x_1^2 + [2]x_1*x_2
   POL(nil) = 0
   POL(rm(x_1, x_2)) = x_2
   POL(s(x_1)) = 0
   POL(true) = 0

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

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, RM_2, IF_RM_3, MINSORT_2, IF_MINSORT_3

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c12_2, c14_1, c21_2, c22_1, c23_1, c25_3, c26_3, c27_1


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

(79) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   app(nil, z0) -> z0
   rm(z0, nil) -> nil
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = [2]x_1
   POL(EQ(x_1, x_2)) = 0
   POL(IF_MIN(x_1, x_2, x_3, x_4)) = 0
   POL(IF_MINSORT(x_1, x_2, x_3)) = x_3^2 + [2]x_2*x_3 + x_2^2
   POL(IF_RM(x_1, x_2, x_3)) = [2]x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = 0
   POL(MINITER(x_1, x_2, x_3)) = 0
   POL(MINSORT(x_1, x_2)) = x_2^2 + [2]x_1*x_2 + x_1^2
   POL(RM(x_1, x_2)) = [2]x_2
   POL(add(x_1, x_2)) = [2] + x_2
   POL(app(x_1, x_2)) = x_1 + x_2
   POL(c10(x_1)) = x_1
   POL(c11(x_1)) = x_1
   POL(c12(x_1, x_2)) = x_1 + x_2
   POL(c14(x_1)) = x_1
   POL(c21(x_1, x_2)) = x_1 + x_2
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(if_min(x_1, x_2, x_3, x_4)) = [1] + [2]x_2 + x_3 + x_4 + x_4^2 + x_3*x_4 + x_2*x_4 + x_3^2 + [2]x_2*x_3 + x_2^2
   POL(if_rm(x_1, x_2, x_3)) = x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = 0
   POL(minIter(x_1, x_2, x_3)) = [1] + [2]x_1^2 + [2]x_1*x_2
   POL(nil) = 0
   POL(rm(x_1, x_2)) = x_2
   POL(s(x_1)) = 0
   POL(true) = 0

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

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, RM_2, IF_RM_3, MINSORT_2, IF_MINSORT_3

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c12_2, c14_1, c21_2, c22_1, c23_1, c25_3, c26_3, c27_1


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

(81) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))

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

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, RM_2, IF_RM_3, MINSORT_2, IF_MINSORT_3

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c12_2, c14_1, c21_2, c22_1, c23_1, c25_3, c26_3, c27_1


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

(83) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINITER(add(z0, z1), z2, z3) -> c12(IF_MIN(le(z0, z3), z1, z2, z3), LE(z0, z3)) by 
   MINITER(add(0, x1), x2, z0) -> c12(IF_MIN(true, x1, x2, z0), LE(0, z0))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0), LE(s(z0), 0))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))

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

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(0, x1), x2, z0) -> c12(IF_MIN(true, x1, x2, z0), LE(0, z0))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0), LE(s(z0), 0))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(0, x1), x2, z0) -> c12(IF_MIN(true, x1, x2, z0), LE(0, z0))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0), LE(s(z0), 0))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, RM_2, IF_RM_3, MINSORT_2, IF_MINSORT_3

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c21_2, c22_1, c23_1, c25_3, c26_3, c27_1, c12_2


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

(85) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   MINITER(add(0, x1), x2, z0) -> c12(IF_MIN(true, x1, x2, z0), LE(0, z0))

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

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0), LE(s(z0), 0))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0), LE(s(z0), 0))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, RM_2, IF_RM_3, MINSORT_2, IF_MINSORT_3

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c21_2, c22_1, c23_1, c25_3, c26_3, c27_1, c12_2


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

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

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, RM_2, IF_RM_3, MINSORT_2, IF_MINSORT_3

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c21_2, c22_1, c23_1, c25_3, c26_3, c27_1, c12_2, c12_1


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

(89) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1)) by 
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)), EQ(0, 0))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)), EQ(0, s(z0)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)), EQ(s(z0), 0))
   RM(s(z0), add(s(z1), x2)) -> c21(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))

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

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)), EQ(0, 0))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)), EQ(0, s(z0)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)), EQ(s(z0), 0))
   RM(s(z0), add(s(z1), x2)) -> c21(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, MINSORT_2, IF_MINSORT_3, RM_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c25_3, c26_3, c27_1, c12_2, c12_1, c21_2


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

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

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(s(z0), add(s(z1), x2)) -> c21(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, MINSORT_2, IF_MINSORT_3, RM_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c25_3, c26_3, c27_1, c12_2, c12_1, c21_2, c21_1


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

(93) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1))) by 
   MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, minIter(add(z0, z1), add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))

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

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(s(z0), add(s(z1), x2)) -> c21(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, minIter(add(z0, z1), add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c26_3, c27_1, c12_2, c12_1, c21_2, c21_1, c25_3


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

(95) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1)) by 
   IF_MINSORT(true, add(z0, nil), x2) -> c26(MINSORT(app(nil, x2), nil), APP(rm(z0, nil), x2), RM(z0, nil))
   IF_MINSORT(true, add(z0, add(z1, z2)), x2) -> c26(MINSORT(app(if_rm(eq(z0, z1), z0, add(z1, z2)), x2), nil), APP(rm(z0, add(z1, z2)), x2), RM(z0, add(z1, z2)))

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

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(s(z0), add(s(z1), x2)) -> c21(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, minIter(add(z0, z1), add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, nil), x2) -> c26(MINSORT(app(nil, x2), nil), APP(rm(z0, nil), x2), RM(z0, nil))
   IF_MINSORT(true, add(z0, add(z1, z2)), x2) -> c26(MINSORT(app(if_rm(eq(z0, z1), z0, add(z1, z2)), x2), nil), APP(rm(z0, add(z1, z2)), x2), RM(z0, add(z1, z2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_2, c12_1, c21_2, c21_1, c25_3, c26_3


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

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

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(s(z0), add(s(z1), x2)) -> c21(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, minIter(add(z0, z1), add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x2) -> c26(MINSORT(app(if_rm(eq(z0, z1), z0, add(z1, z2)), x2), nil), APP(rm(z0, add(z1, z2)), x2), RM(z0, add(z1, z2)))
   IF_MINSORT(true, add(z0, nil), x2) -> c26(MINSORT(app(nil, x2), nil), APP(rm(z0, nil), x2))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_2, c12_1, c21_2, c21_1, c25_3, c26_3, c26_2


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

(99) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINITER(add(s(z0), x1), x2, s(z1)) -> c12(IF_MIN(le(z0, z1), x1, x2, s(z1)), LE(s(z0), s(z1))) by 
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(IF_MIN(true, x1, x2, s(z0)), LE(s(0), s(z0)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))

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

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(s(z0), add(s(z1), x2)) -> c21(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, minIter(add(z0, z1), add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x2) -> c26(MINSORT(app(if_rm(eq(z0, z1), z0, add(z1, z2)), x2), nil), APP(rm(z0, add(z1, z2)), x2), RM(z0, add(z1, z2)))
   IF_MINSORT(true, add(z0, nil), x2) -> c26(MINSORT(app(nil, x2), nil), APP(rm(z0, nil), x2))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(IF_MIN(true, x1, x2, s(z0)), LE(s(0), s(z0)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(IF_MIN(true, x1, x2, s(z0)), LE(s(0), s(z0)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_2, c21_1, c25_3, c26_3, c26_2, c12_2


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

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

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(s(z0), add(s(z1), x2)) -> c21(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, minIter(add(z0, z1), add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x2) -> c26(MINSORT(app(if_rm(eq(z0, z1), z0, add(z1, z2)), x2), nil), APP(rm(z0, add(z1, z2)), x2), RM(z0, add(z1, z2)))
   IF_MINSORT(true, add(z0, nil), x2) -> c26(MINSORT(app(nil, x2), nil), APP(rm(z0, nil), x2))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_2, c21_1, c25_3, c26_3, c26_2, c12_2


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

(103) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace RM(s(z0), add(s(z1), x2)) -> c21(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1))) by 
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c21(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))

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

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, minIter(add(z0, z1), add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x2) -> c26(MINSORT(app(if_rm(eq(z0, z1), z0, add(z1, z2)), x2), nil), APP(rm(z0, add(z1, z2)), x2), RM(z0, add(z1, z2)))
   IF_MINSORT(true, add(z0, nil), x2) -> c26(MINSORT(app(nil, x2), nil), APP(rm(z0, nil), x2))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c21(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c25_3, c26_3, c26_2, c12_2, c21_2


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

(105) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, minIter(add(z0, z1), add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1))) by 
   MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   MINSORT(add(x0, x1), x2) -> c25(EQ(x0, min(add(x0, x1))), MIN(add(x0, x1)))

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

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x2) -> c26(MINSORT(app(if_rm(eq(z0, z1), z0, add(z1, z2)), x2), nil), APP(rm(z0, add(z1, z2)), x2), RM(z0, add(z1, z2)))
   IF_MINSORT(true, add(z0, nil), x2) -> c26(MINSORT(app(nil, x2), nil), APP(rm(z0, nil), x2))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c21(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   MINSORT(add(x0, x1), x2) -> c25(EQ(x0, min(add(x0, x1))), MIN(add(x0, x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c26_3, c26_2, c12_2, c21_2, c25_3, c25_2


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

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

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x2) -> c26(MINSORT(app(if_rm(eq(z0, z1), z0, add(z1, z2)), x2), nil), APP(rm(z0, add(z1, z2)), x2), RM(z0, add(z1, z2)))
   IF_MINSORT(true, add(z0, nil), x2) -> c26(MINSORT(app(nil, x2), nil), APP(rm(z0, nil), x2))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c21(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   MINSORT(add(x0, x1), x2) -> c(EQ(x0, min(add(x0, x1))))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c26_3, c26_2, c12_2, c21_2, c25_3, c_1


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

(109) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(z0, add(z1, z2)), x2) -> c26(MINSORT(app(if_rm(eq(z0, z1), z0, add(z1, z2)), x2), nil), APP(rm(z0, add(z1, z2)), x2), RM(z0, add(z1, z2))) by 
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(MINSORT(app(if_rm(true, 0, add(0, x2)), x3), nil), APP(rm(0, add(0, x2)), x3), RM(0, add(0, x2)))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(MINSORT(app(if_rm(false, 0, add(s(z0), x2)), x3), nil), APP(rm(0, add(s(z0), x2)), x3), RM(0, add(s(z0), x2)))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(MINSORT(app(if_rm(false, s(z0), add(0, x2)), x3), nil), APP(rm(s(z0), add(0, x2)), x3), RM(s(z0), add(0, x2)))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))

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

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   IF_MINSORT(true, add(z0, nil), x2) -> c26(MINSORT(app(nil, x2), nil), APP(rm(z0, nil), x2))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c21(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   MINSORT(add(x0, x1), x2) -> c(EQ(x0, min(add(x0, x1))))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(MINSORT(app(if_rm(true, 0, add(0, x2)), x3), nil), APP(rm(0, add(0, x2)), x3), RM(0, add(0, x2)))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(MINSORT(app(if_rm(false, 0, add(s(z0), x2)), x3), nil), APP(rm(0, add(s(z0), x2)), x3), RM(0, add(s(z0), x2)))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(MINSORT(app(if_rm(false, s(z0), add(0, x2)), x3), nil), APP(rm(s(z0), add(0, x2)), x3), RM(s(z0), add(0, x2)))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c26_2, c12_2, c21_2, c25_3, c_1, c26_3, c26_1


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

(111) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(z0, nil), x2) -> c26(MINSORT(app(nil, x2), nil), APP(rm(z0, nil), x2)) by 
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))

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

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c21(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   MINSORT(add(x0, x1), x2) -> c(EQ(x0, min(add(x0, x1))))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(MINSORT(app(if_rm(true, 0, add(0, x2)), x3), nil), APP(rm(0, add(0, x2)), x3), RM(0, add(0, x2)))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(MINSORT(app(if_rm(false, 0, add(s(z0), x2)), x3), nil), APP(rm(0, add(s(z0), x2)), x3), RM(0, add(s(z0), x2)))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(MINSORT(app(if_rm(false, s(z0), add(0, x2)), x3), nil), APP(rm(s(z0), add(0, x2)), x3), RM(s(z0), add(0, x2)))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c25_3, c_1, c26_3, c26_1, c26_2


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

(113) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MINSORT(add(z0, z1), x2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), x2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1))) by MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
----------------------------------------

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c21(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(EQ(x0, min(add(x0, x1))))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(MINSORT(app(if_rm(true, 0, add(0, x2)), x3), nil), APP(rm(0, add(0, x2)), x3), RM(0, add(0, x2)))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(MINSORT(app(if_rm(false, 0, add(s(z0), x2)), x3), nil), APP(rm(0, add(s(z0), x2)), x3), RM(0, add(s(z0), x2)))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(MINSORT(app(if_rm(false, s(z0), add(0, x2)), x3), nil), APP(rm(s(z0), add(0, x2)), x3), RM(s(z0), add(0, x2)))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c26_2, c25_3


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

(115) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MINSORT(add(x0, x1), x2) -> c(EQ(x0, min(add(x0, x1)))) by MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
----------------------------------------

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c21(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(MINSORT(app(if_rm(true, 0, add(0, x2)), x3), nil), APP(rm(0, add(0, x2)), x3), RM(0, add(0, x2)))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(MINSORT(app(if_rm(false, 0, add(s(z0), x2)), x3), nil), APP(rm(0, add(s(z0), x2)), x3), RM(0, add(s(z0), x2)))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(MINSORT(app(if_rm(false, s(z0), add(0, x2)), x3), nil), APP(rm(s(z0), add(0, x2)), x3), RM(s(z0), add(0, x2)))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, min_1, minIter_3, if_min_4, app_2, rm_2, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c26_2, c25_3


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

(117) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   min(add(z0, z1)) -> minIter(add(z0, z1), add(z0, z1), 0)

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

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c21(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(MINSORT(app(if_rm(true, 0, add(0, x2)), x3), nil), APP(rm(0, add(0, x2)), x3), RM(0, add(0, x2)))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(MINSORT(app(if_rm(false, 0, add(s(z0), x2)), x3), nil), APP(rm(0, add(s(z0), x2)), x3), RM(0, add(s(z0), x2)))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(MINSORT(app(if_rm(false, s(z0), add(0, x2)), x3), nil), APP(rm(s(z0), add(0, x2)), x3), RM(s(z0), add(0, x2)))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1))))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c26_2, c25_3


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

(119) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINITER(add(s(s(z0)), x1), x2, s(s(z1))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(z1))), LE(s(s(z0)), s(s(z1)))) by 
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(IF_MIN(true, x1, x2, s(s(z0))), LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))

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

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c21(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(MINSORT(app(if_rm(true, 0, add(0, x2)), x3), nil), APP(rm(0, add(0, x2)), x3), RM(0, add(0, x2)))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(MINSORT(app(if_rm(false, 0, add(s(z0), x2)), x3), nil), APP(rm(0, add(s(z0), x2)), x3), RM(0, add(s(z0), x2)))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(MINSORT(app(if_rm(false, s(z0), add(0, x2)), x3), nil), APP(rm(s(z0), add(0, x2)), x3), RM(s(z0), add(0, x2)))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(IF_MIN(true, x1, x2, s(s(z0))), LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(IF_MIN(true, x1, x2, s(s(z0))), LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c26_2, c25_3


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

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

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c21(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(MINSORT(app(if_rm(true, 0, add(0, x2)), x3), nil), APP(rm(0, add(0, x2)), x3), RM(0, add(0, x2)))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(MINSORT(app(if_rm(false, 0, add(s(z0), x2)), x3), nil), APP(rm(0, add(s(z0), x2)), x3), RM(0, add(s(z0), x2)))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(MINSORT(app(if_rm(false, s(z0), add(0, x2)), x3), nil), APP(rm(s(z0), add(0, x2)), x3), RM(s(z0), add(0, x2)))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c26_2, c25_3


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

(123) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace RM(s(s(z0)), add(s(s(z1)), x2)) -> c21(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1)))) by 
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))

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

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(MINSORT(app(if_rm(true, 0, add(0, x2)), x3), nil), APP(rm(0, add(0, x2)), x3), RM(0, add(0, x2)))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(MINSORT(app(if_rm(false, 0, add(s(z0), x2)), x3), nil), APP(rm(0, add(s(z0), x2)), x3), RM(0, add(s(z0), x2)))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(MINSORT(app(if_rm(false, s(z0), add(0, x2)), x3), nil), APP(rm(s(z0), add(0, x2)), x3), RM(s(z0), add(0, x2)))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c26_2, c25_3


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

(125) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(MINSORT(app(if_rm(true, 0, add(0, x2)), x3), nil), APP(rm(0, add(0, x2)), x3), RM(0, add(0, x2))) by 
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))

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

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(MINSORT(app(if_rm(false, 0, add(s(z0), x2)), x3), nil), APP(rm(0, add(s(z0), x2)), x3), RM(0, add(s(z0), x2)))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(MINSORT(app(if_rm(false, s(z0), add(0, x2)), x3), nil), APP(rm(s(z0), add(0, x2)), x3), RM(s(z0), add(0, x2)))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c26_2, c25_3


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

(127) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(MINSORT(app(if_rm(false, 0, add(s(z0), x2)), x3), nil), APP(rm(0, add(s(z0), x2)), x3), RM(0, add(s(z0), x2))) by 
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))

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

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(MINSORT(app(if_rm(false, s(z0), add(0, x2)), x3), nil), APP(rm(s(z0), add(0, x2)), x3), RM(s(z0), add(0, x2)))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c26_2, c25_3


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

(129) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(MINSORT(app(if_rm(false, s(z0), add(0, x2)), x3), nil), APP(rm(s(z0), add(0, x2)), x3), RM(s(z0), add(0, x2))) by 
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))

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

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c26_2, c25_3


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

(131) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3), nil), APP(rm(s(z0), add(s(z1), x2)), x3), RM(s(z0), add(s(z1), x2))) by 
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c26(APP(rm(s(x0), add(s(x1), x2)), x3), RM(s(x0), add(s(x1), x2)))

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

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c26(APP(rm(s(x0), add(s(x1), x2)), x3), RM(s(x0), add(s(x1), x2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c26_2, c25_3, c26_3


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

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

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c26_2, c25_3, c26_3, c1_1


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

(135) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(x0, add(x1, x2)), x3) -> c26(APP(rm(x0, add(x1, x2)), x3)) by 
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))

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

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_2, c25_3, c26_3, c26_1, c1_1


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

(137) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(x0, nil), z0) -> c26(MINSORT(z0, nil), APP(rm(x0, nil), z0)) by 
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil), APP(nil, x1))

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

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil), APP(nil, x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c25_3, c26_3, c26_1, c1_1, c26_2


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

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

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c25_3, c26_3, c26_1, c1_1


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

(141) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)), add(z0, z1), z2), EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)), MIN(add(z0, z1))) by 
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), EQ(0, minIter(add(0, x1), add(0, x1), 0)), MIN(add(0, x1)))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(x0, x1), x2) -> c25(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)), MIN(add(x0, x1)))

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

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), EQ(0, minIter(add(0, x1), add(0, x1), 0)), MIN(add(0, x1)))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(x0, x1), x2) -> c25(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)), MIN(add(x0, x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c1_1, c25_3, c25_2


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

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

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(x0, x1), x2) -> c25(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)), MIN(add(x0, x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c1_1, c25_3, c25_2


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

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

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c1_1, c25_3, c25_2, c2_1


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

(147) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINSORT(add(z0, z1), z2) -> c(EQ(z0, minIter(add(z0, z1), add(z0, z1), 0))) by 
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))

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

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1)))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c1_1, c25_3, c25_2, c2_1


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

(149) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINITER(add(s(s(s(z0))), x1), x2, s(s(s(z1)))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(z1)))), LE(s(s(s(z0))), s(s(s(z1))))) by 
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(IF_MIN(true, x1, x2, s(s(s(z0)))), LE(s(s(s(0))), s(s(s(z0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))

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

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(IF_MIN(true, x1, x2, s(s(s(z0)))), LE(s(s(s(0))), s(s(s(z0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(IF_MIN(true, x1, x2, s(s(s(z0)))), LE(s(s(s(0))), s(s(s(z0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c1_1, c25_3, c25_2, c2_1


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

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

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1)))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c1_1, c25_3, c25_2, c2_1


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

(153) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace RM(s(s(s(z0))), add(s(s(s(z1))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), EQ(s(s(s(z0))), s(s(s(z1))))) by 
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))

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

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2)))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_3, c26_1, c1_1, c25_3, c25_2, c2_1


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

(155) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(0, add(0, z2)), x1) -> c26(MINSORT(app(rm(0, z2), x1), nil), APP(rm(0, add(0, z2)), x1), RM(0, add(0, z2))) by 
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(APP(rm(0, add(0, x0)), x1), RM(0, add(0, x0)))

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

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(APP(rm(0, add(0, x0)), x1), RM(0, add(0, x0)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c26_3, c1_1, c25_3, c25_2, c2_1, c26_2


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

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

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c26_3, c1_1, c25_3, c25_2, c2_1, c4_1


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

(159) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(0, add(s(x0), z2)), x2) -> c26(MINSORT(app(add(s(x0), rm(0, z2)), x2), nil), APP(rm(0, add(s(x0), z2)), x2), RM(0, add(s(x0), z2))) by 
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(APP(rm(0, add(s(x0), x1)), x2), RM(0, add(s(x0), x1)))

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

(160)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(APP(rm(0, add(s(x0), x1)), x2), RM(0, add(s(x0), x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c26_3, c1_1, c25_3, c25_2, c2_1, c4_1, c26_2


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

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

(162)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c26_3, c1_1, c25_3, c25_2, c2_1, c4_1, c5_1


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

(163) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(s(x0), add(0, z2)), x2) -> c26(MINSORT(app(add(0, rm(s(x0), z2)), x2), nil), APP(rm(s(x0), add(0, z2)), x2), RM(s(x0), add(0, z2))) by 
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(APP(rm(s(x0), add(0, x1)), x2), RM(s(x0), add(0, x1)))

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

(164)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(APP(rm(s(x0), add(0, x1)), x2), RM(s(x0), add(0, x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c26_3, c1_1, c25_3, c25_2, c2_1, c4_1, c5_1, c26_2


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

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

(166)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c26_3, c1_1, c25_3, c25_2, c2_1, c4_1, c5_1, c7_1


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

(167) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(s(0), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(0), add(s(0), x2)), x3), nil), APP(rm(s(0), add(s(0), x2)), x3), RM(s(0), add(s(0), x2))) by 
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))

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

(168)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c26_3, c1_1, c25_3, c25_2, c2_1, c4_1, c5_1, c7_1


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

(169) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(s(0), add(s(s(z0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(0), add(s(s(z0)), x2)), x3), nil), APP(rm(s(0), add(s(s(z0)), x2)), x3), RM(s(0), add(s(s(z0)), x2))) by 
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))

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

(170)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c26_3, c1_1, c25_3, c25_2, c2_1, c4_1, c5_1, c7_1


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

(171) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(s(s(z0)), add(s(0), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(z0)), add(s(0), x2)), x3), nil), APP(rm(s(s(z0)), add(s(0), x2)), x3), RM(s(s(z0)), add(s(0), x2))) by 
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))

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

(172)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c26_3, c1_1, c25_3, c25_2, c2_1, c4_1, c5_1, c7_1


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

(173) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(s(s(z0)), add(s(s(z1)), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), x3), nil), APP(rm(s(s(z0)), add(s(s(z1)), x2)), x3), RM(s(s(z0)), add(s(s(z1)), x2))) by 
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c26(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3), RM(s(s(x0)), add(s(s(x1)), x2)))

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

(174)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c26(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3), RM(s(s(x0)), add(s(s(x1)), x2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c25_3, c25_2, c2_1, c26_3, c4_1, c5_1, c7_1, c26_2


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

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

(176)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c25_3, c25_2, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1


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

(177) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(APP(rm(s(x0), add(s(x1), x2)), x3)) by 
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))

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

(178)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c25_3, c25_2, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1


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

(179) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF_MINSORT(true, add(z0, add(z1, z2)), x3) -> c26(APP(if_rm(eq(z0, z1), z0, add(z1, z2)), x3)) by 
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))

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

(180)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1)))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c25_3, c25_2, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1


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

(181) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINSORT(add(s(z0), x1), x2) -> c25(IF_MINSORT(eq(s(z0), if_min(false, x1, add(s(z0), x1), 0)), add(s(z0), x1), x2), EQ(s(z0), minIter(add(s(z0), x1), add(s(z0), x1), 0)), MIN(add(s(z0), x1))) by 
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c25(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)), MIN(add(s(x0), x1)))

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

(182)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c25(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)), MIN(add(s(x0), x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c25_2, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3


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

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

(184)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1)))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c25_2, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1


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

(185) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINSORT(add(0, x1), x2) -> c25(IF_MINSORT(eq(0, if_min(true, x1, add(0, x1), 0)), add(0, x1), x2), MIN(add(0, x1))) by 
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))

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

(186)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0)))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_2, c25_1


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

(187) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINSORT(add(x0, x1), x2) -> c2(EQ(x0, minIter(add(x0, x1), add(x0, x1), 0))) by 
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))

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

(188)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_2, c25_1


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

(189) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINSORT(add(z0, z1), x2) -> c(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0))) by 
   MINSORT(add(0, x1), x2) -> c(EQ(0, if_min(true, x1, add(0, x1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))

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

(190)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINSORT(add(0, x1), x2) -> c(EQ(0, if_min(true, x1, add(0, x1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(true, add(z0, z1), z2) -> c26(MINSORT(app(rm(z0, z1), z2), nil), APP(rm(z0, z1), z2), RM(z0, z1))
   MINSORT(add(z0, z1), z2) -> c25(IF_MINSORT(eq(z0, min(add(z0, z1))), add(z0, z1), z2), EQ(z0, min(add(z0, z1))), MIN(add(z0, z1)))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   RM(z0, add(z1, z2)) -> c21(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_2, c25_1


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

(191) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   MINSORT(add(0, x1), x2) -> c(EQ(0, if_min(true, x1, add(0, x1), 0)))

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

(192)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil)))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_2, c25_1


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

(193) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace IF_MINSORT(true, add(0, add(0, nil)), x1) -> c26(MINSORT(app(nil, x1), nil), APP(rm(0, add(0, nil)), x1), RM(0, add(0, nil))) by IF_MINSORT(true, add(0, add(0, nil)), z0) -> c26(MINSORT(app(nil, z0), nil), APP(if_rm(eq(0, 0), 0, add(0, nil)), z0), RM(0, add(0, nil)))
----------------------------------------

(194)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))
   IF_MINSORT(true, add(0, add(0, nil)), z0) -> c26(MINSORT(app(nil, z0), nil), APP(if_rm(eq(0, 0), 0, add(0, nil)), z0), RM(0, add(0, nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_MIN_4, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c14_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_2, c25_1


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

(195) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace IF_MIN(false, z0, z1, z2) -> c14(MINITER(z0, z1, z2)) by 
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))

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

(196)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))
   IF_MINSORT(true, add(0, add(0, nil)), z0) -> c26(MINSORT(app(nil, z0), nil), APP(if_rm(eq(0, 0), 0, add(0, nil)), z0), RM(0, add(0, nil)))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
K tuples:
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, MINITER_3, IF_RM_3, IF_MINSORT_3, RM_2, MINSORT_2, IF_MIN_4

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c11_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_2, c25_1, c14_1


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

(197) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace MINITER(nil, add(z0, z1), z2) -> c11(MINITER(add(z0, z1), add(z0, z1), s(z2))) by 
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))

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

(198)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))
   IF_MINSORT(true, add(0, add(0, nil)), z0) -> c26(MINSORT(app(nil, z0), nil), APP(if_rm(eq(0, 0), 0, add(0, nil)), z0), RM(0, add(0, nil)))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
K tuples:
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, IF_RM_3, IF_MINSORT_3, MINITER_3, RM_2, MINSORT_2, IF_MIN_4

Compound Symbols:   c3_1, c6_1, c8_1, c10_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_2, c25_1, c14_1, c11_1


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

(199) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace EQ(s(z0), s(z1)) -> c3(EQ(z0, z1)) by 
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))

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

(200)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))
   IF_MINSORT(true, add(0, add(0, nil)), z0) -> c26(MINSORT(app(nil, z0), nil), APP(if_rm(eq(0, 0), 0, add(0, nil)), z0), RM(0, add(0, nil)))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
S tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
K tuples:
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   LE_2, APP_2, MIN_1, IF_RM_3, IF_MINSORT_3, MINITER_3, RM_2, MINSORT_2, IF_MIN_4, EQ_2

Compound Symbols:   c6_1, c8_1, c10_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c21_2, c_1, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_2, c25_1, c14_1, c11_1, c3_1


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

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

(202)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))
   IF_MINSORT(true, add(0, add(0, nil)), z0) -> c26(MINSORT(app(nil, z0), nil), APP(if_rm(eq(0, 0), 0, add(0, nil)), z0), RM(0, add(0, nil)))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)))
S tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
K tuples:
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   LE_2, APP_2, MIN_1, IF_RM_3, IF_MINSORT_3, MINITER_3, RM_2, MINSORT_2, IF_MIN_4, EQ_2

Compound Symbols:   c6_1, c8_1, c10_1, c22_1, c23_1, c27_1, c12_1, c21_1, c12_2, c_1, c21_2, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_2, c25_1, c14_1, c11_1, c3_1


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

(203) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace IF_RM(true, z0, add(z1, z2)) -> c22(RM(z0, z2)) by 
   IF_RM(true, 0, add(0, x0)) -> c22(RM(0, x0))
   IF_RM(true, s(s(0)), add(s(s(0)), x0)) -> c22(RM(s(s(0)), x0))
   IF_RM(true, s(s(s(0))), add(s(s(s(0))), x0)) -> c22(RM(s(s(s(0))), x0))
   IF_RM(true, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c22(RM(s(s(s(s(x0)))), x2))
   IF_RM(true, s(0), add(s(0), x0)) -> c22(RM(s(0), x0))

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

(204)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))
   IF_MINSORT(true, add(0, add(0, nil)), z0) -> c26(MINSORT(app(nil, z0), nil), APP(if_rm(eq(0, 0), 0, add(0, nil)), z0), RM(0, add(0, nil)))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)))
   IF_RM(true, 0, add(0, x0)) -> c22(RM(0, x0))
   IF_RM(true, s(s(0)), add(s(s(0)), x0)) -> c22(RM(s(s(0)), x0))
   IF_RM(true, s(s(s(0))), add(s(s(s(0))), x0)) -> c22(RM(s(s(s(0))), x0))
   IF_RM(true, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c22(RM(s(s(s(s(x0)))), x2))
   IF_RM(true, s(0), add(s(0), x0)) -> c22(RM(s(0), x0))
S tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
K tuples:
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2))
   IF_RM(true, 0, add(0, x0)) -> c22(RM(0, x0))
   IF_RM(true, s(s(0)), add(s(s(0)), x0)) -> c22(RM(s(s(0)), x0))
   IF_RM(true, s(s(s(0))), add(s(s(s(0))), x0)) -> c22(RM(s(s(s(0))), x0))
   IF_RM(true, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c22(RM(s(s(s(s(x0)))), x2))
   IF_RM(true, s(0), add(s(0), x0)) -> c22(RM(s(0), x0))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   LE_2, APP_2, MIN_1, IF_RM_3, IF_MINSORT_3, MINITER_3, RM_2, MINSORT_2, IF_MIN_4, EQ_2

Compound Symbols:   c6_1, c8_1, c10_1, c23_1, c27_1, c12_1, c21_1, c12_2, c_1, c21_2, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_2, c25_1, c14_1, c11_1, c3_1, c22_1


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

(205) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace IF_RM(false, z0, add(z1, z2)) -> c23(RM(z0, z2)) by 
   IF_RM(false, 0, add(s(x0), x1)) -> c23(RM(0, x1))
   IF_RM(false, s(x0), add(0, x1)) -> c23(RM(s(x0), x1))
   IF_RM(false, s(s(0)), add(s(s(s(x0))), x1)) -> c23(RM(s(s(0)), x1))
   IF_RM(false, s(s(s(x0))), add(s(s(0)), x1)) -> c23(RM(s(s(s(x0))), x1))
   IF_RM(false, s(s(s(0))), add(s(s(s(s(x0)))), x1)) -> c23(RM(s(s(s(0))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(0))), x1)) -> c23(RM(s(s(s(s(x0)))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c23(RM(s(s(s(s(x0)))), x2))
   IF_RM(false, s(0), add(s(s(x0)), x1)) -> c23(RM(s(0), x1))
   IF_RM(false, s(s(x0)), add(s(0), x1)) -> c23(RM(s(s(x0)), x1))

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

(206)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))
   IF_MINSORT(true, add(0, add(0, nil)), z0) -> c26(MINSORT(app(nil, z0), nil), APP(if_rm(eq(0, 0), 0, add(0, nil)), z0), RM(0, add(0, nil)))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)))
   IF_RM(true, 0, add(0, x0)) -> c22(RM(0, x0))
   IF_RM(true, s(s(0)), add(s(s(0)), x0)) -> c22(RM(s(s(0)), x0))
   IF_RM(true, s(s(s(0))), add(s(s(s(0))), x0)) -> c22(RM(s(s(s(0))), x0))
   IF_RM(true, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c22(RM(s(s(s(s(x0)))), x2))
   IF_RM(true, s(0), add(s(0), x0)) -> c22(RM(s(0), x0))
   IF_RM(false, 0, add(s(x0), x1)) -> c23(RM(0, x1))
   IF_RM(false, s(x0), add(0, x1)) -> c23(RM(s(x0), x1))
   IF_RM(false, s(s(0)), add(s(s(s(x0))), x1)) -> c23(RM(s(s(0)), x1))
   IF_RM(false, s(s(s(x0))), add(s(s(0)), x1)) -> c23(RM(s(s(s(x0))), x1))
   IF_RM(false, s(s(s(0))), add(s(s(s(s(x0)))), x1)) -> c23(RM(s(s(s(0))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(0))), x1)) -> c23(RM(s(s(s(s(x0)))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c23(RM(s(s(s(s(x0)))), x2))
   IF_RM(false, s(0), add(s(s(x0)), x1)) -> c23(RM(s(0), x1))
   IF_RM(false, s(s(x0)), add(s(0), x1)) -> c23(RM(s(s(x0)), x1))
S tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
K tuples:
   IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2)))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, 0, add(0, x0)) -> c22(RM(0, x0))
   IF_RM(true, s(s(0)), add(s(s(0)), x0)) -> c22(RM(s(s(0)), x0))
   IF_RM(true, s(s(s(0))), add(s(s(s(0))), x0)) -> c22(RM(s(s(s(0))), x0))
   IF_RM(true, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c22(RM(s(s(s(s(x0)))), x2))
   IF_RM(true, s(0), add(s(0), x0)) -> c22(RM(s(0), x0))
   IF_RM(false, 0, add(s(x0), x1)) -> c23(RM(0, x1))
   IF_RM(false, s(x0), add(0, x1)) -> c23(RM(s(x0), x1))
   IF_RM(false, s(s(0)), add(s(s(s(x0))), x1)) -> c23(RM(s(s(0)), x1))
   IF_RM(false, s(s(s(x0))), add(s(s(0)), x1)) -> c23(RM(s(s(s(x0))), x1))
   IF_RM(false, s(s(s(0))), add(s(s(s(s(x0)))), x1)) -> c23(RM(s(s(s(0))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(0))), x1)) -> c23(RM(s(s(s(s(x0)))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c23(RM(s(s(s(s(x0)))), x2))
   IF_RM(false, s(0), add(s(s(x0)), x1)) -> c23(RM(s(0), x1))
   IF_RM(false, s(s(x0)), add(s(0), x1)) -> c23(RM(s(s(x0)), x1))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   LE_2, APP_2, MIN_1, IF_MINSORT_3, MINITER_3, RM_2, MINSORT_2, IF_MIN_4, EQ_2, IF_RM_3

Compound Symbols:   c6_1, c8_1, c10_1, c27_1, c12_1, c21_1, c12_2, c_1, c21_2, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_2, c25_1, c14_1, c11_1, c3_1, c22_1, c23_1


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

(207) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace IF_MINSORT(false, add(z0, z1), z2) -> c27(MINSORT(z1, add(z0, z2))) by 
   IF_MINSORT(false, add(s(x0), x1), x2) -> c27(MINSORT(x1, add(s(x0), x2)))
   IF_MINSORT(false, add(0, x0), x1) -> c27(MINSORT(x0, add(0, x1)))

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

(208)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))
   IF_MINSORT(true, add(0, add(0, nil)), z0) -> c26(MINSORT(app(nil, z0), nil), APP(if_rm(eq(0, 0), 0, add(0, nil)), z0), RM(0, add(0, nil)))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)))
   IF_RM(true, 0, add(0, x0)) -> c22(RM(0, x0))
   IF_RM(true, s(s(0)), add(s(s(0)), x0)) -> c22(RM(s(s(0)), x0))
   IF_RM(true, s(s(s(0))), add(s(s(s(0))), x0)) -> c22(RM(s(s(s(0))), x0))
   IF_RM(true, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c22(RM(s(s(s(s(x0)))), x2))
   IF_RM(true, s(0), add(s(0), x0)) -> c22(RM(s(0), x0))
   IF_RM(false, 0, add(s(x0), x1)) -> c23(RM(0, x1))
   IF_RM(false, s(x0), add(0, x1)) -> c23(RM(s(x0), x1))
   IF_RM(false, s(s(0)), add(s(s(s(x0))), x1)) -> c23(RM(s(s(0)), x1))
   IF_RM(false, s(s(s(x0))), add(s(s(0)), x1)) -> c23(RM(s(s(s(x0))), x1))
   IF_RM(false, s(s(s(0))), add(s(s(s(s(x0)))), x1)) -> c23(RM(s(s(s(0))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(0))), x1)) -> c23(RM(s(s(s(s(x0)))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c23(RM(s(s(s(s(x0)))), x2))
   IF_RM(false, s(0), add(s(s(x0)), x1)) -> c23(RM(s(0), x1))
   IF_RM(false, s(s(x0)), add(s(0), x1)) -> c23(RM(s(s(x0)), x1))
   IF_MINSORT(false, add(s(x0), x1), x2) -> c27(MINSORT(x1, add(s(x0), x2)))
   IF_MINSORT(false, add(0, x0), x1) -> c27(MINSORT(x0, add(0, x1)))
S tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
K tuples:
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, 0, add(0, x0)) -> c22(RM(0, x0))
   IF_RM(true, s(s(0)), add(s(s(0)), x0)) -> c22(RM(s(s(0)), x0))
   IF_RM(true, s(s(s(0))), add(s(s(s(0))), x0)) -> c22(RM(s(s(s(0))), x0))
   IF_RM(true, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c22(RM(s(s(s(s(x0)))), x2))
   IF_RM(true, s(0), add(s(0), x0)) -> c22(RM(s(0), x0))
   IF_RM(false, 0, add(s(x0), x1)) -> c23(RM(0, x1))
   IF_RM(false, s(x0), add(0, x1)) -> c23(RM(s(x0), x1))
   IF_RM(false, s(s(0)), add(s(s(s(x0))), x1)) -> c23(RM(s(s(0)), x1))
   IF_RM(false, s(s(s(x0))), add(s(s(0)), x1)) -> c23(RM(s(s(s(x0))), x1))
   IF_RM(false, s(s(s(0))), add(s(s(s(s(x0)))), x1)) -> c23(RM(s(s(s(0))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(0))), x1)) -> c23(RM(s(s(s(s(x0)))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c23(RM(s(s(s(s(x0)))), x2))
   IF_RM(false, s(0), add(s(s(x0)), x1)) -> c23(RM(s(0), x1))
   IF_RM(false, s(s(x0)), add(s(0), x1)) -> c23(RM(s(s(x0)), x1))
   IF_MINSORT(false, add(s(x0), x1), x2) -> c27(MINSORT(x1, add(s(x0), x2)))
   IF_MINSORT(false, add(0, x0), x1) -> c27(MINSORT(x0, add(0, x1)))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   LE_2, APP_2, MIN_1, MINITER_3, RM_2, MINSORT_2, IF_MINSORT_3, IF_MIN_4, EQ_2, IF_RM_3

Compound Symbols:   c6_1, c8_1, c10_1, c12_1, c21_1, c12_2, c_1, c21_2, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_2, c25_1, c14_1, c11_1, c3_1, c22_1, c23_1, c27_1


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

(209) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINSORT(add(0, z0), x1) -> c25(IF_MINSORT(eq(0, 0), add(0, z0), x1), MIN(add(0, z0))) by 
   MINSORT(add(0, x0), x1) -> c25(IF_MINSORT(true, add(0, x0), x1), MIN(add(0, x0)))

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

(210)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))
   IF_MINSORT(true, add(0, add(0, nil)), z0) -> c26(MINSORT(app(nil, z0), nil), APP(if_rm(eq(0, 0), 0, add(0, nil)), z0), RM(0, add(0, nil)))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)))
   IF_RM(true, 0, add(0, x0)) -> c22(RM(0, x0))
   IF_RM(true, s(s(0)), add(s(s(0)), x0)) -> c22(RM(s(s(0)), x0))
   IF_RM(true, s(s(s(0))), add(s(s(s(0))), x0)) -> c22(RM(s(s(s(0))), x0))
   IF_RM(true, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c22(RM(s(s(s(s(x0)))), x2))
   IF_RM(true, s(0), add(s(0), x0)) -> c22(RM(s(0), x0))
   IF_RM(false, 0, add(s(x0), x1)) -> c23(RM(0, x1))
   IF_RM(false, s(x0), add(0, x1)) -> c23(RM(s(x0), x1))
   IF_RM(false, s(s(0)), add(s(s(s(x0))), x1)) -> c23(RM(s(s(0)), x1))
   IF_RM(false, s(s(s(x0))), add(s(s(0)), x1)) -> c23(RM(s(s(s(x0))), x1))
   IF_RM(false, s(s(s(0))), add(s(s(s(s(x0)))), x1)) -> c23(RM(s(s(s(0))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(0))), x1)) -> c23(RM(s(s(s(s(x0)))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c23(RM(s(s(s(s(x0)))), x2))
   IF_RM(false, s(0), add(s(s(x0)), x1)) -> c23(RM(s(0), x1))
   IF_RM(false, s(s(x0)), add(s(0), x1)) -> c23(RM(s(s(x0)), x1))
   IF_MINSORT(false, add(s(x0), x1), x2) -> c27(MINSORT(x1, add(s(x0), x2)))
   IF_MINSORT(false, add(0, x0), x1) -> c27(MINSORT(x0, add(0, x1)))
   MINSORT(add(0, x0), x1) -> c25(IF_MINSORT(true, add(0, x0), x1), MIN(add(0, x0)))
S tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
K tuples:
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, 0, add(0, x0)) -> c22(RM(0, x0))
   IF_RM(true, s(s(0)), add(s(s(0)), x0)) -> c22(RM(s(s(0)), x0))
   IF_RM(true, s(s(s(0))), add(s(s(s(0))), x0)) -> c22(RM(s(s(s(0))), x0))
   IF_RM(true, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c22(RM(s(s(s(s(x0)))), x2))
   IF_RM(true, s(0), add(s(0), x0)) -> c22(RM(s(0), x0))
   IF_RM(false, 0, add(s(x0), x1)) -> c23(RM(0, x1))
   IF_RM(false, s(x0), add(0, x1)) -> c23(RM(s(x0), x1))
   IF_RM(false, s(s(0)), add(s(s(s(x0))), x1)) -> c23(RM(s(s(0)), x1))
   IF_RM(false, s(s(s(x0))), add(s(s(0)), x1)) -> c23(RM(s(s(s(x0))), x1))
   IF_RM(false, s(s(s(0))), add(s(s(s(s(x0)))), x1)) -> c23(RM(s(s(s(0))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(0))), x1)) -> c23(RM(s(s(s(s(x0)))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c23(RM(s(s(s(s(x0)))), x2))
   IF_RM(false, s(0), add(s(s(x0)), x1)) -> c23(RM(s(0), x1))
   IF_RM(false, s(s(x0)), add(s(0), x1)) -> c23(RM(s(s(x0)), x1))
   IF_MINSORT(false, add(s(x0), x1), x2) -> c27(MINSORT(x1, add(s(x0), x2)))
   IF_MINSORT(false, add(0, x0), x1) -> c27(MINSORT(x0, add(0, x1)))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   LE_2, APP_2, MIN_1, MINITER_3, RM_2, MINSORT_2, IF_MINSORT_3, IF_MIN_4, EQ_2, IF_RM_3

Compound Symbols:   c6_1, c8_1, c10_1, c12_1, c21_1, c12_2, c_1, c21_2, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_1, c14_1, c11_1, c3_1, c22_1, c23_1, c27_1, c25_2


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

(211) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   IF_MINSORT(false, add(0, x0), x1) -> c27(MINSORT(x0, add(0, x1)))

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

(212)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_min(true, z0, z1, z2) -> z2
   if_min(false, z0, z1, z2) -> minIter(z0, z1, z2)
   minIter(add(z0, z1), z2, z3) -> if_min(le(z0, z3), z1, z2, z3)
   minIter(nil, add(z0, z1), z2) -> minIter(add(z0, z1), add(z0, z1), s(z2))
Tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   RM(0, add(0, x2)) -> c21(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c21(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c21(IF_RM(false, s(z0), add(0, x2)))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   RM(s(x0), add(s(x1), x2)) -> c21(EQ(s(x0), s(x1)))
   MINSORT(add(x0, x1), x2) -> c(MIN(add(x0, x1)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   RM(s(s(0)), add(s(s(0)), x2)) -> c21(IF_RM(true, s(s(0)), add(s(s(0)), x2)), EQ(s(s(0)), s(s(0))))
   RM(s(s(0)), add(s(s(s(z0))), x2)) -> c21(IF_RM(false, s(s(0)), add(s(s(s(z0))), x2)), EQ(s(s(0)), s(s(s(z0)))))
   RM(s(s(s(z0))), add(s(s(0)), x2)) -> c21(IF_RM(false, s(s(s(z0))), add(s(s(0)), x2)), EQ(s(s(s(z0))), s(s(0))))
   RM(s(s(x0)), add(s(s(x1)), x2)) -> c21(EQ(s(s(x0)), s(s(x1))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c26(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c26(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c26(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(s(x1), x2)), x3) -> c1(RM(s(x0), add(s(x1), x2)))
   IF_MINSORT(true, add(z0, nil), x1) -> c26(MINSORT(x1, nil))
   MINSORT(add(x0, x1), x2) -> c2(MIN(add(x0, x1)))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   RM(s(s(s(0))), add(s(s(s(0))), x2)) -> c21(IF_RM(true, s(s(s(0))), add(s(s(s(0))), x2)), EQ(s(s(s(0))), s(s(s(0)))))
   RM(s(s(s(0))), add(s(s(s(s(z0)))), x2)) -> c21(IF_RM(false, s(s(s(0))), add(s(s(s(s(z0)))), x2)), EQ(s(s(s(0))), s(s(s(s(z0))))))
   RM(s(s(s(s(z0)))), add(s(s(s(0))), x2)) -> c21(IF_RM(false, s(s(s(s(z0)))), add(s(s(s(0))), x2)), EQ(s(s(s(s(z0)))), s(s(s(0)))))
   RM(s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)) -> c21(IF_RM(eq(z0, z1), s(s(s(s(z0)))), add(s(s(s(s(z1)))), x2)), EQ(s(s(s(s(z0)))), s(s(s(s(z1))))))
   RM(s(s(s(x0))), add(s(s(s(x1))), x2)) -> c21(EQ(s(s(s(x0))), s(s(s(x1)))))
   IF_MINSORT(true, add(0, add(0, add(z1, z2))), x1) -> c26(MINSORT(app(if_rm(eq(0, z1), 0, add(z1, z2)), x1), nil), APP(rm(0, add(0, add(z1, z2))), x1), RM(0, add(0, add(z1, z2))))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(APP(rm(0, add(0, x0)), x1))
   IF_MINSORT(true, add(0, add(0, x0)), x1) -> c4(RM(0, add(0, x0)))
   IF_MINSORT(true, add(0, add(s(x0), x1)), z2) -> c26(MINSORT(add(s(x0), app(rm(0, x1), z2)), nil), APP(rm(0, add(s(x0), x1)), z2), RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(0, add(s(x0), nil)), x2) -> c26(MINSORT(app(add(s(x0), nil), x2), nil), APP(rm(0, add(s(x0), nil)), x2), RM(0, add(s(x0), nil)))
   IF_MINSORT(true, add(0, add(s(x0), add(z1, z2))), x2) -> c26(MINSORT(app(add(s(x0), if_rm(eq(0, z1), 0, add(z1, z2))), x2), nil), APP(rm(0, add(s(x0), add(z1, z2))), x2), RM(0, add(s(x0), add(z1, z2))))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(APP(rm(0, add(s(x0), x1)), x2))
   IF_MINSORT(true, add(0, add(s(x0), x1)), x2) -> c5(RM(0, add(s(x0), x1)))
   IF_MINSORT(true, add(s(x0), add(0, x1)), z2) -> c26(MINSORT(add(0, app(rm(s(x0), x1), z2)), nil), APP(rm(s(x0), add(0, x1)), z2), RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(x0), add(0, nil)), x2) -> c26(MINSORT(app(add(0, nil), x2), nil), APP(rm(s(x0), add(0, nil)), x2), RM(s(x0), add(0, nil)))
   IF_MINSORT(true, add(s(x0), add(0, add(z1, z2))), x2) -> c26(MINSORT(app(add(0, if_rm(eq(s(x0), z1), s(x0), add(z1, z2))), x2), nil), APP(rm(s(x0), add(0, add(z1, z2))), x2), RM(s(x0), add(0, add(z1, z2))))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(APP(rm(s(x0), add(0, x1)), x2))
   IF_MINSORT(true, add(s(x0), add(0, x1)), x2) -> c7(RM(s(x0), add(0, x1)))
   IF_MINSORT(true, add(s(0), add(s(0), z2)), x1) -> c26(MINSORT(app(rm(s(0), z2), x1), nil), APP(rm(s(0), add(s(0), z2)), x1), RM(s(0), add(s(0), z2)))
   IF_MINSORT(true, add(s(0), add(s(0), x0)), x1) -> c26(RM(s(0), add(s(0), x0)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), z2)), x2) -> c26(MINSORT(app(add(s(s(x0)), rm(s(0), z2)), x2), nil), APP(rm(s(0), add(s(s(x0)), z2)), x2), RM(s(0), add(s(s(x0)), z2)))
   IF_MINSORT(true, add(s(0), add(s(s(x0)), x1)), x2) -> c26(RM(s(0), add(s(s(x0)), x1)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), z2)), x2) -> c26(MINSORT(app(add(s(0), rm(s(s(x0)), z2)), x2), nil), APP(rm(s(s(x0)), add(s(0), z2)), x2), RM(s(s(x0)), add(s(0), z2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(0), x1)), x2) -> c26(RM(s(s(x0)), add(s(0), x1)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(true, s(s(0)), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(0)), x2)), x3), RM(s(s(0)), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(0)), add(s(s(s(z0))), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(0)), add(s(s(s(z0))), x2)), x3), nil), APP(rm(s(s(0)), add(s(s(s(z0))), x2)), x3), RM(s(s(0)), add(s(s(s(z0))), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(0)), x2)), x3) -> c26(MINSORT(app(if_rm(false, s(s(s(z0))), add(s(s(0)), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(0)), x2)), x3), RM(s(s(s(z0))), add(s(s(0)), x2)))
   IF_MINSORT(true, add(s(s(s(z0))), add(s(s(s(z1))), x2)), x3) -> c26(MINSORT(app(if_rm(eq(z0, z1), s(s(s(z0))), add(s(s(s(z1))), x2)), x3), nil), APP(rm(s(s(s(z0))), add(s(s(s(z1))), x2)), x3), RM(s(s(s(z0))), add(s(s(s(z1))), x2)))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(APP(rm(s(s(x0)), add(s(s(x1)), x2)), x3))
   IF_MINSORT(true, add(s(s(x0)), add(s(s(x1)), x2)), x3) -> c9(RM(s(s(x0)), add(s(s(x1)), x2)))
   IF_MINSORT(true, add(s(x0), add(s(x1), z2)), x3) -> c1(APP(if_rm(eq(s(x0), s(x1)), s(x0), add(s(x1), z2)), x3))
   IF_MINSORT(true, add(0, add(0, x2)), x3) -> c26(APP(if_rm(true, 0, add(0, x2)), x3))
   IF_MINSORT(true, add(0, add(s(z0), x2)), x3) -> c26(APP(if_rm(false, 0, add(s(z0), x2)), x3))
   IF_MINSORT(true, add(s(z0), add(0, x2)), x3) -> c26(APP(if_rm(false, s(z0), add(0, x2)), x3))
   IF_MINSORT(true, add(s(z0), add(s(z1), x2)), x3) -> c26(APP(if_rm(eq(z0, z1), s(z0), add(s(z1), x2)), x3))
   MINSORT(add(s(x0), z0), x2) -> c25(IF_MINSORT(eq(s(x0), minIter(z0, add(s(x0), z0), 0)), add(s(x0), z0), x2), EQ(s(x0), minIter(add(s(x0), z0), add(s(x0), z0), 0)), MIN(add(s(x0), z0)))
   MINSORT(add(s(x0), x1), x2) -> c13(EQ(s(x0), minIter(add(s(x0), x1), add(s(x0), x1), 0)))
   MINSORT(add(s(x0), x1), x2) -> c13(MIN(add(s(x0), x1)))
   MINSORT(add(0, x0), x1) -> c25(MIN(add(0, x0)))
   MINSORT(add(z0, z1), x2) -> c2(EQ(z0, if_min(le(z0, 0), z1, add(z0, z1), 0)))
   MINSORT(add(s(z0), x1), x2) -> c(EQ(s(z0), if_min(false, x1, add(s(z0), x1), 0)))
   IF_MINSORT(true, add(0, add(0, nil)), z0) -> c26(MINSORT(app(nil, z0), nil), APP(if_rm(eq(0, 0), 0, add(0, nil)), z0), RM(0, add(0, nil)))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
   RM(s(0), add(s(0), x2)) -> c21(IF_RM(true, s(0), add(s(0), x2)))
   RM(s(0), add(s(s(z0)), x2)) -> c21(IF_RM(false, s(0), add(s(s(z0)), x2)))
   RM(s(s(z0)), add(s(0), x2)) -> c21(IF_RM(false, s(s(z0)), add(s(0), x2)))
   IF_RM(true, 0, add(0, x0)) -> c22(RM(0, x0))
   IF_RM(true, s(s(0)), add(s(s(0)), x0)) -> c22(RM(s(s(0)), x0))
   IF_RM(true, s(s(s(0))), add(s(s(s(0))), x0)) -> c22(RM(s(s(s(0))), x0))
   IF_RM(true, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c22(RM(s(s(s(s(x0)))), x2))
   IF_RM(true, s(0), add(s(0), x0)) -> c22(RM(s(0), x0))
   IF_RM(false, 0, add(s(x0), x1)) -> c23(RM(0, x1))
   IF_RM(false, s(x0), add(0, x1)) -> c23(RM(s(x0), x1))
   IF_RM(false, s(s(0)), add(s(s(s(x0))), x1)) -> c23(RM(s(s(0)), x1))
   IF_RM(false, s(s(s(x0))), add(s(s(0)), x1)) -> c23(RM(s(s(s(x0))), x1))
   IF_RM(false, s(s(s(0))), add(s(s(s(s(x0)))), x1)) -> c23(RM(s(s(s(0))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(0))), x1)) -> c23(RM(s(s(s(s(x0)))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c23(RM(s(s(s(s(x0)))), x2))
   IF_RM(false, s(0), add(s(s(x0)), x1)) -> c23(RM(s(0), x1))
   IF_RM(false, s(s(x0)), add(s(0), x1)) -> c23(RM(s(s(x0)), x1))
   IF_MINSORT(false, add(s(x0), x1), x2) -> c27(MINSORT(x1, add(s(x0), x2)))
   MINSORT(add(0, x0), x1) -> c25(IF_MINSORT(true, add(0, x0), x1), MIN(add(0, x0)))
S tuples:
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   MINITER(add(s(z0), x1), x2, 0) -> c12(IF_MIN(false, x1, x2, 0))
   MINITER(add(s(s(z0)), x1), x2, s(0)) -> c12(IF_MIN(false, x1, x2, s(0)), LE(s(s(z0)), s(0)))
   MINITER(add(s(x0), x1), x2, s(x3)) -> c12(LE(s(x0), s(x3)))
   MINITER(add(s(0), x1), x2, s(z0)) -> c12(LE(s(0), s(z0)))
   MINITER(add(s(s(s(z0))), x1), x2, s(s(0))) -> c12(IF_MIN(false, x1, x2, s(s(0))), LE(s(s(s(z0))), s(s(0))))
   MINITER(add(s(s(x0)), x1), x2, s(s(x3))) -> c12(LE(s(s(x0)), s(s(x3))))
   MINITER(add(s(s(0)), x1), x2, s(s(z0))) -> c12(LE(s(s(0)), s(s(z0))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(0)))) -> c12(IF_MIN(false, x1, x2, s(s(s(0)))), LE(s(s(s(s(z0)))), s(s(s(0)))))
   MINITER(add(s(s(s(s(z0)))), x1), x2, s(s(s(s(z1))))) -> c12(IF_MIN(le(z0, z1), x1, x2, s(s(s(s(z1))))), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   MINITER(add(s(s(s(x0))), x1), x2, s(s(s(x3)))) -> c12(LE(s(s(s(x0))), s(s(s(x3)))))
   MINITER(add(s(s(s(0))), x1), x2, s(s(s(z0)))) -> c12(LE(s(s(s(0))), s(s(s(z0)))))
   IF_MIN(false, x1, x2, 0) -> c14(MINITER(x1, x2, 0))
   IF_MIN(false, x1, x2, s(0)) -> c14(MINITER(x1, x2, s(0)))
   IF_MIN(false, x1, x2, s(s(0))) -> c14(MINITER(x1, x2, s(s(0))))
   IF_MIN(false, x1, x2, s(s(s(0)))) -> c14(MINITER(x1, x2, s(s(s(0)))))
   IF_MIN(false, x1, x2, s(s(s(s(x3))))) -> c14(MINITER(x1, x2, s(s(s(s(x3))))))
   MINITER(nil, add(z0, z1), 0) -> c11(MINITER(add(z0, z1), add(z0, z1), s(0)))
   MINITER(nil, add(z0, z1), s(0)) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(0))))
   MINITER(nil, add(z0, z1), s(s(0))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(0)))))
   MINITER(nil, add(z0, z1), s(s(s(0)))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(0))))))
   MINITER(nil, add(z0, z1), s(s(s(s(x2))))) -> c11(MINITER(add(z0, z1), add(z0, z1), s(s(s(s(s(x2)))))))
   EQ(s(s(y0)), s(s(y1))) -> c3(EQ(s(y0), s(y1)))
K tuples:
   MIN(add(z0, z1)) -> c10(MINITER(add(z0, z1), add(z0, z1), 0))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_RM(true, 0, add(0, x0)) -> c22(RM(0, x0))
   IF_RM(true, s(s(0)), add(s(s(0)), x0)) -> c22(RM(s(s(0)), x0))
   IF_RM(true, s(s(s(0))), add(s(s(s(0))), x0)) -> c22(RM(s(s(s(0))), x0))
   IF_RM(true, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c22(RM(s(s(s(s(x0)))), x2))
   IF_RM(true, s(0), add(s(0), x0)) -> c22(RM(s(0), x0))
   IF_RM(false, 0, add(s(x0), x1)) -> c23(RM(0, x1))
   IF_RM(false, s(x0), add(0, x1)) -> c23(RM(s(x0), x1))
   IF_RM(false, s(s(0)), add(s(s(s(x0))), x1)) -> c23(RM(s(s(0)), x1))
   IF_RM(false, s(s(s(x0))), add(s(s(0)), x1)) -> c23(RM(s(s(s(x0))), x1))
   IF_RM(false, s(s(s(0))), add(s(s(s(s(x0)))), x1)) -> c23(RM(s(s(s(0))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(0))), x1)) -> c23(RM(s(s(s(s(x0)))), x1))
   IF_RM(false, s(s(s(s(x0)))), add(s(s(s(s(x1)))), x2)) -> c23(RM(s(s(s(s(x0)))), x2))
   IF_RM(false, s(0), add(s(s(x0)), x1)) -> c23(RM(s(0), x1))
   IF_RM(false, s(s(x0)), add(s(0), x1)) -> c23(RM(s(s(x0)), x1))
   IF_MINSORT(false, add(s(x0), x1), x2) -> c27(MINSORT(x1, add(s(x0), x2)))
Defined Rule Symbols:   le_2, eq_2, app_2, if_rm_3, rm_2, if_min_4, minIter_3

Defined Pair Symbols:   LE_2, APP_2, MIN_1, MINITER_3, RM_2, MINSORT_2, IF_MINSORT_3, IF_MIN_4, EQ_2, IF_RM_3

Compound Symbols:   c6_1, c8_1, c10_1, c12_1, c21_1, c12_2, c_1, c21_2, c26_1, c1_1, c2_1, c26_3, c4_1, c5_1, c7_1, c9_1, c25_3, c13_1, c25_1, c14_1, c11_1, c3_1, c22_1, c23_1, c27_1, c25_2