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


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

(0) CpxRelTRS
(1) SInnermostTerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 468 ms]
(2) CpxRelTRS
(3) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(4) CpxRelTRS
(5) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(6) CpxTRS
(7) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(8) CpxWeightedTrs
    (9) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (10) CpxTypedWeightedTrs
    (11) CompletionProof [UPPER BOUND(ID), 0 ms]
    (12) CpxTypedWeightedCompleteTrs
        (13) NarrowingProof [BOTH BOUNDS(ID, ID), 111 ms]
        (14) CpxTypedWeightedCompleteTrs
        (15) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 16 ms]
        (16) CpxRNTS
        (17) InliningProof [UPPER BOUND(ID), 384 ms]
        (18) CpxRNTS
        (19) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (20) CpxRNTS
    (21) CompletionProof [UPPER BOUND(ID), 0 ms]
    (22) CpxTypedWeightedCompleteTrs
        (23) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (24) CpxRNTS
(25) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(26) CdtProblem
    (27) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (28) CdtProblem
    (29) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (30) CdtProblem
    (31) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (32) CdtProblem
    (33) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 168 ms]
    (34) CdtProblem
    (35) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 89 ms]
    (36) CdtProblem
    (37) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (38) CdtProblem
    (39) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (40) CdtProblem
    (41) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (42) CdtProblem
    (43) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (44) CdtProblem
    (45) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (46) CdtProblem
    (47) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (48) CdtProblem
    (49) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (50) CdtProblem
    (51) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (52) CdtProblem
    (53) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (54) CdtProblem
    (55) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (56) CdtProblem
    (57) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (58) CdtProblem
    (59) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (60) CdtProblem
    (61) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (62) CdtProblem
    (63) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (64) CdtProblem
    (65) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (66) CdtProblem
    (67) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (68) CdtProblem
    (69) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (70) CdtProblem
    (71) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (72) CdtProblem
    (73) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (74) CdtProblem
    (75) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (76) CdtProblem
    (77) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (78) CdtProblem
    (79) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (80) CdtProblem
    (81) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (82) CdtProblem
    (83) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (84) CdtProblem
    (85) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (86) CdtProblem
    (87) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (88) CdtProblem
    (89) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (90) CdtProblem
    (91) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (92) CdtProblem
    (93) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (94) CdtProblem
    (95) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (96) CdtProblem
    (97) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (98) CdtProblem
    (99) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (100) CdtProblem
    (101) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (102) CdtProblem
    (103) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 2 ms]
    (104) CdtProblem
    (105) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (106) CdtProblem
    (107) CdtRewritingProof [BOTH BOUNDS(ID, ID), 3 ms]
    (108) CdtProblem
    (109) CdtRewritingProof [BOTH BOUNDS(ID, ID), 17 ms]
    (110) CdtProblem
    (111) CdtRewritingProof [BOTH BOUNDS(ID, ID), 12 ms]
    (112) CdtProblem
    (113) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (114) CdtProblem
    (115) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (116) CdtProblem
    (117) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (118) CdtProblem
    (119) CdtRewritingProof [BOTH BOUNDS(ID, ID), 14 ms]
    (120) CdtProblem
    (121) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (122) CdtProblem
    (123) CdtRewritingProof [BOTH BOUNDS(ID, ID), 22 ms]
    (124) CdtProblem
    (125) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (126) CdtProblem
    (127) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (128) CdtProblem
    (129) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (130) CdtProblem
    (131) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 17 ms]
    (132) CdtProblem
    (133) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (134) CdtProblem


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

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


The TRS R consists of the following rules:

   subst(x, a, App(e1, e2)) -> mkapp(subst(x, a, e1), subst(x, a, e2))
   subst(x, a, Lam(var, exp)) -> subst[True][Ite](eqTerm(x, V(var)), x, a, Lam(var, exp))
   red(App(e1, e2)) -> red[Let](App(e1, e2), red(e1))
   red(Lam(int, term)) -> Lam(int, term)
   subst(x, a, V(int)) -> subst[Ite](eqTerm(x, V(int)), x, a, V(int))
   red(V(int)) -> V(int)
   eqTerm(App(t11, t12), App(t21, t22)) -> and(eqTerm(t11, t21), eqTerm(t12, t22))
   eqTerm(App(t11, t12), Lam(i2, l2)) -> False
   eqTerm(App(t11, t12), V(v2)) -> False
   eqTerm(Lam(i1, l1), App(t21, t22)) -> False
   eqTerm(Lam(i1, l1), Lam(i2, l2)) -> and(!EQ(i1, i2), eqTerm(l1, l2))
   eqTerm(Lam(i1, l1), V(v2)) -> False
   eqTerm(V(v1), App(t21, t22)) -> False
   eqTerm(V(v1), Lam(i2, l2)) -> False
   eqTerm(V(v1), V(v2)) -> !EQ(v1, v2)
   mklam(V(name), e) -> Lam(name, e)
   lamvar(Lam(var, exp)) -> V(var)
   lambody(Lam(var, exp)) -> exp
   isvar(App(t1, t2)) -> False
   isvar(Lam(int, term)) -> False
   isvar(V(int)) -> True
   islam(App(t1, t2)) -> False
   islam(Lam(int, term)) -> True
   islam(V(int)) -> False
   appe2(App(e1, e2)) -> e2
   appe1(App(e1, e2)) -> e1
   mkapp(e1, e2) -> App(e1, e2)
   lambdaint(e) -> red(e)

The (relative) TRS S consists of the following rules:

   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(x), S(y)) -> !EQ(x, y)
   !EQ(0, S(y)) -> False
   !EQ(S(x), 0) -> False
   !EQ(0, 0) -> True
   red[Let][Let](e, Lam(var, exp), a) -> red(subst(V(var), a, exp))
   subst[True][Ite](False, x, a, Lam(var, exp)) -> mklam(V(var), subst(x, a, exp))
   red[Let][Let](e, App(t1, t2), e2) -> App(App(t1, t2), e2)
   red[Let][Let](e, V(int), e2) -> App(V(int), e2)
   red[Let](App(e1, e2), f) -> red[Let][Let](App(e1, e2), f, red(e2))
   subst[True][Ite](True, x, a, e) -> e
   subst[Ite](False, x, a, e) -> e
   subst[Ite](True, x, a, e) -> a

Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(1) SInnermostTerminationProof (BOTH CONCRETE BOUNDS(ID, ID))
proved innermost termination of relative rules
----------------------------------------

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


The TRS R consists of the following rules:

   subst(x, a, App(e1, e2)) -> mkapp(subst(x, a, e1), subst(x, a, e2))
   subst(x, a, Lam(var, exp)) -> subst[True][Ite](eqTerm(x, V(var)), x, a, Lam(var, exp))
   red(App(e1, e2)) -> red[Let](App(e1, e2), red(e1))
   red(Lam(int, term)) -> Lam(int, term)
   subst(x, a, V(int)) -> subst[Ite](eqTerm(x, V(int)), x, a, V(int))
   red(V(int)) -> V(int)
   eqTerm(App(t11, t12), App(t21, t22)) -> and(eqTerm(t11, t21), eqTerm(t12, t22))
   eqTerm(App(t11, t12), Lam(i2, l2)) -> False
   eqTerm(App(t11, t12), V(v2)) -> False
   eqTerm(Lam(i1, l1), App(t21, t22)) -> False
   eqTerm(Lam(i1, l1), Lam(i2, l2)) -> and(!EQ(i1, i2), eqTerm(l1, l2))
   eqTerm(Lam(i1, l1), V(v2)) -> False
   eqTerm(V(v1), App(t21, t22)) -> False
   eqTerm(V(v1), Lam(i2, l2)) -> False
   eqTerm(V(v1), V(v2)) -> !EQ(v1, v2)
   mklam(V(name), e) -> Lam(name, e)
   lamvar(Lam(var, exp)) -> V(var)
   lambody(Lam(var, exp)) -> exp
   isvar(App(t1, t2)) -> False
   isvar(Lam(int, term)) -> False
   isvar(V(int)) -> True
   islam(App(t1, t2)) -> False
   islam(Lam(int, term)) -> True
   islam(V(int)) -> False
   appe2(App(e1, e2)) -> e2
   appe1(App(e1, e2)) -> e1
   mkapp(e1, e2) -> App(e1, e2)
   lambdaint(e) -> red(e)

The (relative) TRS S consists of the following rules:

   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(x), S(y)) -> !EQ(x, y)
   !EQ(0, S(y)) -> False
   !EQ(S(x), 0) -> False
   !EQ(0, 0) -> True
   red[Let][Let](e, Lam(var, exp), a) -> red(subst(V(var), a, exp))
   subst[True][Ite](False, x, a, Lam(var, exp)) -> mklam(V(var), subst(x, a, exp))
   red[Let][Let](e, App(t1, t2), e2) -> App(App(t1, t2), e2)
   red[Let][Let](e, V(int), e2) -> App(V(int), e2)
   red[Let](App(e1, e2), f) -> red[Let][Let](App(e1, e2), f, red(e2))
   subst[True][Ite](True, x, a, e) -> e
   subst[Ite](False, x, a, e) -> e
   subst[Ite](True, x, a, e) -> a

Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

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

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


The TRS R consists of the following rules:

   subst(x, a, App(e1, e2)) -> mkapp(subst(x, a, e1), subst(x, a, e2))
   subst(x, a, Lam(var, exp)) -> subst[True][Ite](eqTerm(x, V(var)), x, a, Lam(var, exp))
   red(App(e1, e2)) -> red[Let](App(e1, e2), red(e1))
   red(Lam(int, term)) -> Lam(int, term)
   subst(x, a, V(int)) -> subst[Ite](eqTerm(x, V(int)), x, a, V(int))
   red(V(int)) -> V(int)
   eqTerm(App(t11, t12), App(t21, t22)) -> and(eqTerm(t11, t21), eqTerm(t12, t22))
   eqTerm(App(t11, t12), Lam(i2, l2)) -> False
   eqTerm(App(t11, t12), V(v2)) -> False
   eqTerm(Lam(i1, l1), App(t21, t22)) -> False
   eqTerm(Lam(i1, l1), Lam(i2, l2)) -> and(!EQ(i1, i2), eqTerm(l1, l2))
   eqTerm(Lam(i1, l1), V(v2)) -> False
   eqTerm(V(v1), App(t21, t22)) -> False
   eqTerm(V(v1), Lam(i2, l2)) -> False
   eqTerm(V(v1), V(v2)) -> !EQ(v1, v2)
   mklam(V(name), e) -> Lam(name, e)
   lamvar(Lam(var, exp)) -> V(var)
   lambody(Lam(var, exp)) -> exp
   isvar(App(t1, t2)) -> False
   isvar(Lam(int, term)) -> False
   isvar(V(int)) -> True
   islam(App(t1, t2)) -> False
   islam(Lam(int, term)) -> True
   islam(V(int)) -> False
   appe2(App(e1, e2)) -> e2
   appe1(App(e1, e2)) -> e1
   mkapp(e1, e2) -> App(e1, e2)
   lambdaint(e) -> red(e)

The (relative) TRS S consists of the following rules:

   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(x), S(y)) -> !EQ(x, y)
   !EQ(0', S(y)) -> False
   !EQ(S(x), 0') -> False
   !EQ(0', 0') -> True
   red[Let][Let](e, Lam(var, exp), a) -> red(subst(V(var), a, exp))
   subst[True][Ite](False, x, a, Lam(var, exp)) -> mklam(V(var), subst(x, a, exp))
   red[Let][Let](e, App(t1, t2), e2) -> App(App(t1, t2), e2)
   red[Let][Let](e, V(int), e2) -> App(V(int), e2)
   red[Let](App(e1, e2), f) -> red[Let][Let](App(e1, e2), f, red(e2))
   subst[True][Ite](True, x, a, e) -> e
   subst[Ite](False, x, a, e) -> e
   subst[Ite](True, x, a, e) -> a

Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

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

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


The TRS R consists of the following rules:

   subst(x, a, App(e1, e2)) -> mkapp(subst(x, a, e1), subst(x, a, e2))
   subst(x, a, Lam(var, exp)) -> subst[True][Ite](eqTerm(x, V(var)), x, a, Lam(var, exp))
   red(App(e1, e2)) -> red[Let](App(e1, e2), red(e1))
   red(Lam(int, term)) -> Lam(int, term)
   subst(x, a, V(int)) -> subst[Ite](eqTerm(x, V(int)), x, a, V(int))
   red(V(int)) -> V(int)
   eqTerm(App(t11, t12), App(t21, t22)) -> and(eqTerm(t11, t21), eqTerm(t12, t22))
   eqTerm(App(t11, t12), Lam(i2, l2)) -> False
   eqTerm(App(t11, t12), V(v2)) -> False
   eqTerm(Lam(i1, l1), App(t21, t22)) -> False
   eqTerm(Lam(i1, l1), Lam(i2, l2)) -> and(!EQ(i1, i2), eqTerm(l1, l2))
   eqTerm(Lam(i1, l1), V(v2)) -> False
   eqTerm(V(v1), App(t21, t22)) -> False
   eqTerm(V(v1), Lam(i2, l2)) -> False
   eqTerm(V(v1), V(v2)) -> !EQ(v1, v2)
   mklam(V(name), e) -> Lam(name, e)
   lamvar(Lam(var, exp)) -> V(var)
   lambody(Lam(var, exp)) -> exp
   isvar(App(t1, t2)) -> False
   isvar(Lam(int, term)) -> False
   isvar(V(int)) -> True
   islam(App(t1, t2)) -> False
   islam(Lam(int, term)) -> True
   islam(V(int)) -> False
   appe2(App(e1, e2)) -> e2
   appe1(App(e1, e2)) -> e1
   mkapp(e1, e2) -> App(e1, e2)
   lambdaint(e) -> red(e)
   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(x), S(y)) -> !EQ(x, y)
   !EQ(0, S(y)) -> False
   !EQ(S(x), 0) -> False
   !EQ(0, 0) -> True
   red[Let][Let](e, Lam(var, exp), a) -> red(subst(V(var), a, exp))
   subst[True][Ite](False, x, a, Lam(var, exp)) -> mklam(V(var), subst(x, a, exp))
   red[Let][Let](e, App(t1, t2), e2) -> App(App(t1, t2), e2)
   red[Let][Let](e, V(int), e2) -> App(V(int), e2)
   red[Let](App(e1, e2), f) -> red[Let][Let](App(e1, e2), f, red(e2))
   subst[True][Ite](True, x, a, e) -> e
   subst[Ite](False, x, a, e) -> e
   subst[Ite](True, x, a, e) -> a

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

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

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


The TRS R consists of the following rules:

   subst(x, a, App(e1, e2)) -> mkapp(subst(x, a, e1), subst(x, a, e2)) [1]
   subst(x, a, Lam(var, exp)) -> subst[True][Ite](eqTerm(x, V(var)), x, a, Lam(var, exp)) [1]
   red(App(e1, e2)) -> red[Let](App(e1, e2), red(e1)) [1]
   red(Lam(int, term)) -> Lam(int, term) [1]
   subst(x, a, V(int)) -> subst[Ite](eqTerm(x, V(int)), x, a, V(int)) [1]
   red(V(int)) -> V(int) [1]
   eqTerm(App(t11, t12), App(t21, t22)) -> and(eqTerm(t11, t21), eqTerm(t12, t22)) [1]
   eqTerm(App(t11, t12), Lam(i2, l2)) -> False [1]
   eqTerm(App(t11, t12), V(v2)) -> False [1]
   eqTerm(Lam(i1, l1), App(t21, t22)) -> False [1]
   eqTerm(Lam(i1, l1), Lam(i2, l2)) -> and(!EQ(i1, i2), eqTerm(l1, l2)) [1]
   eqTerm(Lam(i1, l1), V(v2)) -> False [1]
   eqTerm(V(v1), App(t21, t22)) -> False [1]
   eqTerm(V(v1), Lam(i2, l2)) -> False [1]
   eqTerm(V(v1), V(v2)) -> !EQ(v1, v2) [1]
   mklam(V(name), e) -> Lam(name, e) [1]
   lamvar(Lam(var, exp)) -> V(var) [1]
   lambody(Lam(var, exp)) -> exp [1]
   isvar(App(t1, t2)) -> False [1]
   isvar(Lam(int, term)) -> False [1]
   isvar(V(int)) -> True [1]
   islam(App(t1, t2)) -> False [1]
   islam(Lam(int, term)) -> True [1]
   islam(V(int)) -> False [1]
   appe2(App(e1, e2)) -> e2 [1]
   appe1(App(e1, e2)) -> e1 [1]
   mkapp(e1, e2) -> App(e1, e2) [1]
   lambdaint(e) -> red(e) [1]
   and(False, False) -> False [0]
   and(True, False) -> False [0]
   and(False, True) -> False [0]
   and(True, True) -> True [0]
   !EQ(S(x), S(y)) -> !EQ(x, y) [0]
   !EQ(0, S(y)) -> False [0]
   !EQ(S(x), 0) -> False [0]
   !EQ(0, 0) -> True [0]
   red[Let][Let](e, Lam(var, exp), a) -> red(subst(V(var), a, exp)) [0]
   subst[True][Ite](False, x, a, Lam(var, exp)) -> mklam(V(var), subst(x, a, exp)) [0]
   red[Let][Let](e, App(t1, t2), e2) -> App(App(t1, t2), e2) [0]
   red[Let][Let](e, V(int), e2) -> App(V(int), e2) [0]
   red[Let](App(e1, e2), f) -> red[Let][Let](App(e1, e2), f, red(e2)) [0]
   subst[True][Ite](True, x, a, e) -> e [0]
   subst[Ite](False, x, a, e) -> e [0]
   subst[Ite](True, x, a, e) -> a [0]

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

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

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

   subst(x, a, App(e1, e2)) -> mkapp(subst(x, a, e1), subst(x, a, e2)) [1]
   subst(x, a, Lam(var, exp)) -> subst[True][Ite](eqTerm(x, V(var)), x, a, Lam(var, exp)) [1]
   red(App(e1, e2)) -> red[Let](App(e1, e2), red(e1)) [1]
   red(Lam(int, term)) -> Lam(int, term) [1]
   subst(x, a, V(int)) -> subst[Ite](eqTerm(x, V(int)), x, a, V(int)) [1]
   red(V(int)) -> V(int) [1]
   eqTerm(App(t11, t12), App(t21, t22)) -> and(eqTerm(t11, t21), eqTerm(t12, t22)) [1]
   eqTerm(App(t11, t12), Lam(i2, l2)) -> False [1]
   eqTerm(App(t11, t12), V(v2)) -> False [1]
   eqTerm(Lam(i1, l1), App(t21, t22)) -> False [1]
   eqTerm(Lam(i1, l1), Lam(i2, l2)) -> and(!EQ(i1, i2), eqTerm(l1, l2)) [1]
   eqTerm(Lam(i1, l1), V(v2)) -> False [1]
   eqTerm(V(v1), App(t21, t22)) -> False [1]
   eqTerm(V(v1), Lam(i2, l2)) -> False [1]
   eqTerm(V(v1), V(v2)) -> !EQ(v1, v2) [1]
   mklam(V(name), e) -> Lam(name, e) [1]
   lamvar(Lam(var, exp)) -> V(var) [1]
   lambody(Lam(var, exp)) -> exp [1]
   isvar(App(t1, t2)) -> False [1]
   isvar(Lam(int, term)) -> False [1]
   isvar(V(int)) -> True [1]
   islam(App(t1, t2)) -> False [1]
   islam(Lam(int, term)) -> True [1]
   islam(V(int)) -> False [1]
   appe2(App(e1, e2)) -> e2 [1]
   appe1(App(e1, e2)) -> e1 [1]
   mkapp(e1, e2) -> App(e1, e2) [1]
   lambdaint(e) -> red(e) [1]
   and(False, False) -> False [0]
   and(True, False) -> False [0]
   and(False, True) -> False [0]
   and(True, True) -> True [0]
   !EQ(S(x), S(y)) -> !EQ(x, y) [0]
   !EQ(0, S(y)) -> False [0]
   !EQ(S(x), 0) -> False [0]
   !EQ(0, 0) -> True [0]
   red[Let][Let](e, Lam(var, exp), a) -> red(subst(V(var), a, exp)) [0]
   subst[True][Ite](False, x, a, Lam(var, exp)) -> mklam(V(var), subst(x, a, exp)) [0]
   red[Let][Let](e, App(t1, t2), e2) -> App(App(t1, t2), e2) [0]
   red[Let][Let](e, V(int), e2) -> App(V(int), e2) [0]
   red[Let](App(e1, e2), f) -> red[Let][Let](App(e1, e2), f, red(e2)) [0]
   subst[True][Ite](True, x, a, e) -> e [0]
   subst[Ite](False, x, a, e) -> e [0]
   subst[Ite](True, x, a, e) -> a [0]

The TRS has the following type information:
subst :: App:Lam:V -> App:Lam:V -> App:Lam:V -> App:Lam:V
App :: App:Lam:V -> App:Lam:V -> App:Lam:V
mkapp :: App:Lam:V -> App:Lam:V -> App:Lam:V
Lam :: S:0 -> App:Lam:V -> App:Lam:V
subst[True][Ite] :: False:True -> App:Lam:V -> App:Lam:V -> App:Lam:V -> App:Lam:V
eqTerm :: App:Lam:V -> App:Lam:V -> False:True
V :: S:0 -> App:Lam:V
red :: App:Lam:V -> App:Lam:V
red[Let] :: App:Lam:V -> App:Lam:V -> App:Lam:V
subst[Ite] :: False:True -> App:Lam:V -> App:Lam:V -> App:Lam:V -> App:Lam:V
and :: False:True -> False:True -> False:True
False :: False:True
!EQ :: S:0 -> S:0 -> False:True
mklam :: App:Lam:V -> App:Lam:V -> App:Lam:V
lamvar :: App:Lam:V -> App:Lam:V
lambody :: App:Lam:V -> App:Lam:V
isvar :: App:Lam:V -> False:True
True :: False:True
islam :: App:Lam:V -> False:True
appe2 :: App:Lam:V -> App:Lam:V
appe1 :: App:Lam:V -> App:Lam:V
lambdaint :: App:Lam:V -> App:Lam:V
S :: S:0 -> S:0
0 :: S:0
red[Let][Let] :: App:Lam:V -> App:Lam:V -> App:Lam:V -> App:Lam:V

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

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

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

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

   lamvar_1
   lambody_1
   isvar_1
   islam_1
   appe2_1
   appe1_1
   lambdaint_1

(c) The following functions are completely defined:

   subst_3
   eqTerm_2
   red_1
   mkapp_2
   mklam_2
   and_2
   !EQ_2
   red[Let][Let]_3
   subst[True][Ite]_4
   red[Let]_2
   subst[Ite]_4

Due to the following rules being added:

   and(v0, v1) -> null_and [0]
   !EQ(v0, v1) -> null_!EQ [0]
   red[Let][Let](v0, v1, v2) -> const [0]
   subst[True][Ite](v0, v1, v2, v3) -> const [0]
   red[Let](v0, v1) -> const [0]
   subst[Ite](v0, v1, v2, v3) -> const [0]
   subst(v0, v1, v2) -> const [0]
   eqTerm(v0, v1) -> null_eqTerm [0]
   red(v0) -> const [0]
   mklam(v0, v1) -> const [0]

And the following fresh constants:    null_and, null_!EQ, const, null_eqTerm

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

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

   subst(x, a, App(e1, e2)) -> mkapp(subst(x, a, e1), subst(x, a, e2)) [1]
   subst(x, a, Lam(var, exp)) -> subst[True][Ite](eqTerm(x, V(var)), x, a, Lam(var, exp)) [1]
   red(App(e1, e2)) -> red[Let](App(e1, e2), red(e1)) [1]
   red(Lam(int, term)) -> Lam(int, term) [1]
   subst(x, a, V(int)) -> subst[Ite](eqTerm(x, V(int)), x, a, V(int)) [1]
   red(V(int)) -> V(int) [1]
   eqTerm(App(t11, t12), App(t21, t22)) -> and(eqTerm(t11, t21), eqTerm(t12, t22)) [1]
   eqTerm(App(t11, t12), Lam(i2, l2)) -> False [1]
   eqTerm(App(t11, t12), V(v2)) -> False [1]
   eqTerm(Lam(i1, l1), App(t21, t22)) -> False [1]
   eqTerm(Lam(i1, l1), Lam(i2, l2)) -> and(!EQ(i1, i2), eqTerm(l1, l2)) [1]
   eqTerm(Lam(i1, l1), V(v2)) -> False [1]
   eqTerm(V(v1), App(t21, t22)) -> False [1]
   eqTerm(V(v1), Lam(i2, l2)) -> False [1]
   eqTerm(V(v1), V(v2)) -> !EQ(v1, v2) [1]
   mklam(V(name), e) -> Lam(name, e) [1]
   lamvar(Lam(var, exp)) -> V(var) [1]
   lambody(Lam(var, exp)) -> exp [1]
   isvar(App(t1, t2)) -> False [1]
   isvar(Lam(int, term)) -> False [1]
   isvar(V(int)) -> True [1]
   islam(App(t1, t2)) -> False [1]
   islam(Lam(int, term)) -> True [1]
   islam(V(int)) -> False [1]
   appe2(App(e1, e2)) -> e2 [1]
   appe1(App(e1, e2)) -> e1 [1]
   mkapp(e1, e2) -> App(e1, e2) [1]
   lambdaint(e) -> red(e) [1]
   and(False, False) -> False [0]
   and(True, False) -> False [0]
   and(False, True) -> False [0]
   and(True, True) -> True [0]
   !EQ(S(x), S(y)) -> !EQ(x, y) [0]
   !EQ(0, S(y)) -> False [0]
   !EQ(S(x), 0) -> False [0]
   !EQ(0, 0) -> True [0]
   red[Let][Let](e, Lam(var, exp), a) -> red(subst(V(var), a, exp)) [0]
   subst[True][Ite](False, x, a, Lam(var, exp)) -> mklam(V(var), subst(x, a, exp)) [0]
   red[Let][Let](e, App(t1, t2), e2) -> App(App(t1, t2), e2) [0]
   red[Let][Let](e, V(int), e2) -> App(V(int), e2) [0]
   red[Let](App(e1, e2), f) -> red[Let][Let](App(e1, e2), f, red(e2)) [0]
   subst[True][Ite](True, x, a, e) -> e [0]
   subst[Ite](False, x, a, e) -> e [0]
   subst[Ite](True, x, a, e) -> a [0]
   and(v0, v1) -> null_and [0]
   !EQ(v0, v1) -> null_!EQ [0]
   red[Let][Let](v0, v1, v2) -> const [0]
   subst[True][Ite](v0, v1, v2, v3) -> const [0]
   red[Let](v0, v1) -> const [0]
   subst[Ite](v0, v1, v2, v3) -> const [0]
   subst(v0, v1, v2) -> const [0]
   eqTerm(v0, v1) -> null_eqTerm [0]
   red(v0) -> const [0]
   mklam(v0, v1) -> const [0]

The TRS has the following type information:
subst :: App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
App :: App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
mkapp :: App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
Lam :: S:0 -> App:Lam:V:const -> App:Lam:V:const
subst[True][Ite] :: False:True:null_and:null_!EQ:null_eqTerm -> App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
eqTerm :: App:Lam:V:const -> App:Lam:V:const -> False:True:null_and:null_!EQ:null_eqTerm
V :: S:0 -> App:Lam:V:const
red :: App:Lam:V:const -> App:Lam:V:const
red[Let] :: App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
subst[Ite] :: False:True:null_and:null_!EQ:null_eqTerm -> App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
and :: False:True:null_and:null_!EQ:null_eqTerm -> False:True:null_and:null_!EQ:null_eqTerm -> False:True:null_and:null_!EQ:null_eqTerm
False :: False:True:null_and:null_!EQ:null_eqTerm
!EQ :: S:0 -> S:0 -> False:True:null_and:null_!EQ:null_eqTerm
mklam :: App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
lamvar :: App:Lam:V:const -> App:Lam:V:const
lambody :: App:Lam:V:const -> App:Lam:V:const
isvar :: App:Lam:V:const -> False:True:null_and:null_!EQ:null_eqTerm
True :: False:True:null_and:null_!EQ:null_eqTerm
islam :: App:Lam:V:const -> False:True:null_and:null_!EQ:null_eqTerm
appe2 :: App:Lam:V:const -> App:Lam:V:const
appe1 :: App:Lam:V:const -> App:Lam:V:const
lambdaint :: App:Lam:V:const -> App:Lam:V:const
S :: S:0 -> S:0
0 :: S:0
red[Let][Let] :: App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
null_and :: False:True:null_and:null_!EQ:null_eqTerm
null_!EQ :: False:True:null_and:null_!EQ:null_eqTerm
const :: App:Lam:V:const
null_eqTerm :: False:True:null_and:null_!EQ:null_eqTerm

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

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

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

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

   subst(x, a, App(App(e1', e2'), App(e1'', e2''))) -> mkapp(mkapp(subst(x, a, e1'), subst(x, a, e2')), mkapp(subst(x, a, e1''), subst(x, a, e2''))) [3]
   subst(x, a, App(App(e1', e2'), Lam(var'', exp''))) -> mkapp(mkapp(subst(x, a, e1'), subst(x, a, e2')), subst[True][Ite](eqTerm(x, V(var'')), x, a, Lam(var'', exp''))) [3]
   subst(x, a, App(App(e1', e2'), V(int''))) -> mkapp(mkapp(subst(x, a, e1'), subst(x, a, e2')), subst[Ite](eqTerm(x, V(int'')), x, a, V(int''))) [3]
   subst(x, a, App(App(e1', e2'), e2)) -> mkapp(mkapp(subst(x, a, e1'), subst(x, a, e2')), const) [2]
   subst(x, a, App(Lam(var', exp'), App(e11, e21))) -> mkapp(subst[True][Ite](eqTerm(x, V(var')), x, a, Lam(var', exp')), mkapp(subst(x, a, e11), subst(x, a, e21))) [3]
   subst(x, a, App(Lam(var', exp'), Lam(var1, exp1))) -> mkapp(subst[True][Ite](eqTerm(x, V(var')), x, a, Lam(var', exp')), subst[True][Ite](eqTerm(x, V(var1)), x, a, Lam(var1, exp1))) [3]
   subst(x, a, App(Lam(var', exp'), V(int1))) -> mkapp(subst[True][Ite](eqTerm(x, V(var')), x, a, Lam(var', exp')), subst[Ite](eqTerm(x, V(int1)), x, a, V(int1))) [3]
   subst(x, a, App(Lam(var', exp'), e2)) -> mkapp(subst[True][Ite](eqTerm(x, V(var')), x, a, Lam(var', exp')), const) [2]
   subst(x, a, App(V(int'), App(e12, e22))) -> mkapp(subst[Ite](eqTerm(x, V(int')), x, a, V(int')), mkapp(subst(x, a, e12), subst(x, a, e22))) [3]
   subst(x, a, App(V(int'), Lam(var2, exp2))) -> mkapp(subst[Ite](eqTerm(x, V(int')), x, a, V(int')), subst[True][Ite](eqTerm(x, V(var2)), x, a, Lam(var2, exp2))) [3]
   subst(x, a, App(V(int'), V(int2))) -> mkapp(subst[Ite](eqTerm(x, V(int')), x, a, V(int')), subst[Ite](eqTerm(x, V(int2)), x, a, V(int2))) [3]
   subst(x, a, App(V(int'), e2)) -> mkapp(subst[Ite](eqTerm(x, V(int')), x, a, V(int')), const) [2]
   subst(x, a, App(e1, App(e13, e23))) -> mkapp(const, mkapp(subst(x, a, e13), subst(x, a, e23))) [2]
   subst(x, a, App(e1, Lam(var3, exp3))) -> mkapp(const, subst[True][Ite](eqTerm(x, V(var3)), x, a, Lam(var3, exp3))) [2]
   subst(x, a, App(e1, V(int3))) -> mkapp(const, subst[Ite](eqTerm(x, V(int3)), x, a, V(int3))) [2]
   subst(x, a, App(e1, e2)) -> mkapp(const, const) [1]
   subst(App(t11', t12'), a, Lam(var, exp)) -> subst[True][Ite](False, App(t11', t12'), a, Lam(var, exp)) [2]
   subst(Lam(i1', l1'), a, Lam(var, exp)) -> subst[True][Ite](False, Lam(i1', l1'), a, Lam(var, exp)) [2]
   subst(V(v1'), a, Lam(var, exp)) -> subst[True][Ite](!EQ(v1', var), V(v1'), a, Lam(var, exp)) [2]
   subst(x, a, Lam(var, exp)) -> subst[True][Ite](null_eqTerm, x, a, Lam(var, exp)) [1]
   red(App(App(e14, e24), e2)) -> red[Let](App(App(e14, e24), e2), red[Let](App(e14, e24), red(e14))) [2]
   red(App(Lam(int4, term'), e2)) -> red[Let](App(Lam(int4, term'), e2), Lam(int4, term')) [2]
   red(App(V(int5), e2)) -> red[Let](App(V(int5), e2), V(int5)) [2]
   red(App(e1, e2)) -> red[Let](App(e1, e2), const) [1]
   red(Lam(int, term)) -> Lam(int, term) [1]
   subst(App(t11'', t12''), a, V(int)) -> subst[Ite](False, App(t11'', t12''), a, V(int)) [2]
   subst(Lam(i1'', l1''), a, V(int)) -> subst[Ite](False, Lam(i1'', l1''), a, V(int)) [2]
   subst(V(v1''), a, V(int)) -> subst[Ite](!EQ(v1'', int), V(v1''), a, V(int)) [2]
   subst(x, a, V(int)) -> subst[Ite](null_eqTerm, x, a, V(int)) [1]
   red(V(int)) -> V(int) [1]
   eqTerm(App(t11, t12), App(t21, t22)) -> and(eqTerm(t11, t21), eqTerm(t12, t22)) [1]
   eqTerm(App(t11, t12), Lam(i2, l2)) -> False [1]
   eqTerm(App(t11, t12), V(v2)) -> False [1]
   eqTerm(Lam(i1, l1), App(t21, t22)) -> False [1]
   eqTerm(Lam(i1, l1), Lam(i2, l2)) -> and(!EQ(i1, i2), eqTerm(l1, l2)) [1]
   eqTerm(Lam(i1, l1), V(v2)) -> False [1]
   eqTerm(V(v1), App(t21, t22)) -> False [1]
   eqTerm(V(v1), Lam(i2, l2)) -> False [1]
   eqTerm(V(v1), V(v2)) -> !EQ(v1, v2) [1]
   mklam(V(name), e) -> Lam(name, e) [1]
   lamvar(Lam(var, exp)) -> V(var) [1]
   lambody(Lam(var, exp)) -> exp [1]
   isvar(App(t1, t2)) -> False [1]
   isvar(Lam(int, term)) -> False [1]
   isvar(V(int)) -> True [1]
   islam(App(t1, t2)) -> False [1]
   islam(Lam(int, term)) -> True [1]
   islam(V(int)) -> False [1]
   appe2(App(e1, e2)) -> e2 [1]
   appe1(App(e1, e2)) -> e1 [1]
   mkapp(e1, e2) -> App(e1, e2) [1]
   lambdaint(e) -> red(e) [1]
   and(False, False) -> False [0]
   and(True, False) -> False [0]
   and(False, True) -> False [0]
   and(True, True) -> True [0]
   !EQ(S(x), S(y)) -> !EQ(x, y) [0]
   !EQ(0, S(y)) -> False [0]
   !EQ(S(x), 0) -> False [0]
   !EQ(0, 0) -> True [0]
   red[Let][Let](e, Lam(var, App(e15, e25)), a) -> red(mkapp(subst(V(var), a, e15), subst(V(var), a, e25))) [1]
   red[Let][Let](e, Lam(var, Lam(var4, exp4)), a) -> red(subst[True][Ite](eqTerm(V(var), V(var4)), V(var), a, Lam(var4, exp4))) [1]
   red[Let][Let](e, Lam(var, V(int6)), a) -> red(subst[Ite](eqTerm(V(var), V(int6)), V(var), a, V(int6))) [1]
   red[Let][Let](e, Lam(var, exp), a) -> red(const) [0]
   subst[True][Ite](False, x, a, Lam(var, App(e16, e26))) -> mklam(V(var), mkapp(subst(x, a, e16), subst(x, a, e26))) [1]
   subst[True][Ite](False, x, a, Lam(var, Lam(var5, exp5))) -> mklam(V(var), subst[True][Ite](eqTerm(x, V(var5)), x, a, Lam(var5, exp5))) [1]
   subst[True][Ite](False, x, a, Lam(var, V(int7))) -> mklam(V(var), subst[Ite](eqTerm(x, V(int7)), x, a, V(int7))) [1]
   subst[True][Ite](False, x, a, Lam(var, exp)) -> mklam(V(var), const) [0]
   red[Let][Let](e, App(t1, t2), e2) -> App(App(t1, t2), e2) [0]
   red[Let][Let](e, V(int), e2) -> App(V(int), e2) [0]
   red[Let](App(e1, App(e17, e27)), f) -> red[Let][Let](App(e1, App(e17, e27)), f, red[Let](App(e17, e27), red(e17))) [1]
   red[Let](App(e1, Lam(int8, term'')), f) -> red[Let][Let](App(e1, Lam(int8, term'')), f, Lam(int8, term'')) [1]
   red[Let](App(e1, V(int9)), f) -> red[Let][Let](App(e1, V(int9)), f, V(int9)) [1]
   red[Let](App(e1, e2), f) -> red[Let][Let](App(e1, e2), f, const) [0]
   subst[True][Ite](True, x, a, e) -> e [0]
   subst[Ite](False, x, a, e) -> e [0]
   subst[Ite](True, x, a, e) -> a [0]
   and(v0, v1) -> null_and [0]
   !EQ(v0, v1) -> null_!EQ [0]
   red[Let][Let](v0, v1, v2) -> const [0]
   subst[True][Ite](v0, v1, v2, v3) -> const [0]
   red[Let](v0, v1) -> const [0]
   subst[Ite](v0, v1, v2, v3) -> const [0]
   subst(v0, v1, v2) -> const [0]
   eqTerm(v0, v1) -> null_eqTerm [0]
   red(v0) -> const [0]
   mklam(v0, v1) -> const [0]

The TRS has the following type information:
subst :: App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
App :: App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
mkapp :: App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
Lam :: S:0 -> App:Lam:V:const -> App:Lam:V:const
subst[True][Ite] :: False:True:null_and:null_!EQ:null_eqTerm -> App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
eqTerm :: App:Lam:V:const -> App:Lam:V:const -> False:True:null_and:null_!EQ:null_eqTerm
V :: S:0 -> App:Lam:V:const
red :: App:Lam:V:const -> App:Lam:V:const
red[Let] :: App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
subst[Ite] :: False:True:null_and:null_!EQ:null_eqTerm -> App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
and :: False:True:null_and:null_!EQ:null_eqTerm -> False:True:null_and:null_!EQ:null_eqTerm -> False:True:null_and:null_!EQ:null_eqTerm
False :: False:True:null_and:null_!EQ:null_eqTerm
!EQ :: S:0 -> S:0 -> False:True:null_and:null_!EQ:null_eqTerm
mklam :: App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
lamvar :: App:Lam:V:const -> App:Lam:V:const
lambody :: App:Lam:V:const -> App:Lam:V:const
isvar :: App:Lam:V:const -> False:True:null_and:null_!EQ:null_eqTerm
True :: False:True:null_and:null_!EQ:null_eqTerm
islam :: App:Lam:V:const -> False:True:null_and:null_!EQ:null_eqTerm
appe2 :: App:Lam:V:const -> App:Lam:V:const
appe1 :: App:Lam:V:const -> App:Lam:V:const
lambdaint :: App:Lam:V:const -> App:Lam:V:const
S :: S:0 -> S:0
0 :: S:0
red[Let][Let] :: App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const -> App:Lam:V:const
null_and :: False:True:null_and:null_!EQ:null_eqTerm
null_!EQ :: False:True:null_and:null_!EQ:null_eqTerm
const :: App:Lam:V:const
null_eqTerm :: False:True:null_and:null_!EQ:null_eqTerm

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

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

   False => 1
   True => 2
   0 => 0
   null_and => 0
   null_!EQ => 0
   const => 0
   null_eqTerm => 0

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

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

   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' = 1 + y, y >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: x >= 0, z = 1 + x, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   !EQ(z, z') -{ 0 }-> !EQ(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   appe1(z) -{ 1 }-> e1 :|: e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   appe2(z) -{ 1 }-> e2 :|: e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   eqTerm(z, z') -{ 1 }-> and(eqTerm(t11, t21), eqTerm(t12, t22)) :|: z' = 1 + t21 + t22, t11 >= 0, t21 >= 0, t12 >= 0, z = 1 + t11 + t12, t22 >= 0
   eqTerm(z, z') -{ 1 }-> and(!EQ(i1, i2), eqTerm(l1, l2)) :|: i1 >= 0, z' = 1 + i2 + l2, l1 >= 0, i2 >= 0, l2 >= 0, z = 1 + i1 + l1
   eqTerm(z, z') -{ 1 }-> 1 :|: z' = 1 + i2 + l2, t11 >= 0, t12 >= 0, i2 >= 0, l2 >= 0, z = 1 + t11 + t12
   eqTerm(z, z') -{ 1 }-> 1 :|: z' = 1 + v2, t11 >= 0, t12 >= 0, z = 1 + t11 + t12, v2 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: i1 >= 0, z' = 1 + t21 + t22, t21 >= 0, l1 >= 0, z = 1 + i1 + l1, t22 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: i1 >= 0, z' = 1 + v2, l1 >= 0, z = 1 + i1 + l1, v2 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: z = 1 + v1, z' = 1 + t21 + t22, v1 >= 0, t21 >= 0, t22 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: z = 1 + v1, z' = 1 + i2 + l2, v1 >= 0, i2 >= 0, l2 >= 0
   eqTerm(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   eqTerm(z, z') -{ 1 }-> !EQ(v1, v2) :|: z' = 1 + v2, z = 1 + v1, v1 >= 0, v2 >= 0
   islam(z) -{ 1 }-> 2 :|: term >= 0, z = 1 + int + term, int >= 0
   islam(z) -{ 1 }-> 1 :|: z = 1 + t1 + t2, t1 >= 0, t2 >= 0
   islam(z) -{ 1 }-> 1 :|: int >= 0, z = 1 + int
   isvar(z) -{ 1 }-> 2 :|: int >= 0, z = 1 + int
   isvar(z) -{ 1 }-> 1 :|: z = 1 + t1 + t2, t1 >= 0, t2 >= 0
   isvar(z) -{ 1 }-> 1 :|: term >= 0, z = 1 + int + term, int >= 0
   lambdaint(z) -{ 1 }-> red(e) :|: z = e, e >= 0
   lambody(z) -{ 1 }-> exp :|: var >= 0, z = 1 + var + exp, exp >= 0
   lamvar(z) -{ 1 }-> 1 + var :|: var >= 0, z = 1 + var + exp, exp >= 0
   mkapp(z, z') -{ 1 }-> 1 + e1 + e2 :|: z' = e2, z = e1, e1 >= 0, e2 >= 0
   mklam(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   mklam(z, z') -{ 1 }-> 1 + name + e :|: z' = e, z = 1 + name, e >= 0, name >= 0
   red(z) -{ 1 }-> red[Let](1 + e1 + e2, 0) :|: e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   red(z) -{ 2 }-> red[Let](1 + (1 + int5) + e2, 1 + int5) :|: z = 1 + (1 + int5) + e2, int5 >= 0, e2 >= 0
   red(z) -{ 2 }-> red[Let](1 + (1 + e14 + e24) + e2, red[Let](1 + e14 + e24, red(e14))) :|: e24 >= 0, z = 1 + (1 + e14 + e24) + e2, e2 >= 0, e14 >= 0
   red(z) -{ 2 }-> red[Let](1 + (1 + int4 + term') + e2, 1 + int4 + term') :|: term' >= 0, int4 >= 0, z = 1 + (1 + int4 + term') + e2, e2 >= 0
   red(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   red(z) -{ 1 }-> 1 + int :|: int >= 0, z = 1 + int
   red(z) -{ 1 }-> 1 + int + term :|: term >= 0, z = 1 + int + term, int >= 0
   red[Let](z, z') -{ 0 }-> red[Let][Let](1 + e1 + e2, f, 0) :|: f >= 0, z' = f, e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   red[Let](z, z') -{ 1 }-> red[Let][Let](1 + e1 + (1 + int9), f, 1 + int9) :|: f >= 0, z = 1 + e1 + (1 + int9), z' = f, int9 >= 0, e1 >= 0
   red[Let](z, z') -{ 1 }-> red[Let][Let](1 + e1 + (1 + e17 + e27), f, red[Let](1 + e17 + e27, red(e17))) :|: f >= 0, e17 >= 0, e27 >= 0, z' = f, z = 1 + e1 + (1 + e17 + e27), e1 >= 0
   red[Let](z, z') -{ 1 }-> red[Let][Let](1 + e1 + (1 + int8 + term''), f, 1 + int8 + term'') :|: z = 1 + e1 + (1 + int8 + term''), f >= 0, term'' >= 0, z' = f, e1 >= 0, int8 >= 0
   red[Let](z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   red[Let][Let](z, z', z'') -{ 1 }-> red(subst[True][Ite](eqTerm(1 + var, 1 + var4), 1 + var, a, 1 + var4 + exp4)) :|: z = e, var >= 0, a >= 0, z'' = a, z' = 1 + var + (1 + var4 + exp4), var4 >= 0, exp4 >= 0, e >= 0
   red[Let][Let](z, z', z'') -{ 1 }-> red(subst[Ite](eqTerm(1 + var, 1 + int6), 1 + var, a, 1 + int6)) :|: z = e, var >= 0, int6 >= 0, a >= 0, z'' = a, e >= 0, z' = 1 + var + (1 + int6)
   red[Let][Let](z, z', z'') -{ 1 }-> red(mkapp(subst(1 + var, a, e15), subst(1 + var, a, e25))) :|: z = e, var >= 0, a >= 0, z'' = a, z' = 1 + var + (1 + e15 + e25), e >= 0, e25 >= 0, e15 >= 0
   red[Let][Let](z, z', z'') -{ 0 }-> red(0) :|: z = e, var >= 0, a >= 0, z'' = a, z' = 1 + var + exp, e >= 0, exp >= 0
   red[Let][Let](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   red[Let][Let](z, z', z'') -{ 0 }-> 1 + (1 + int) + e2 :|: z = e, e >= 0, int >= 0, e2 >= 0, z' = 1 + int, z'' = e2
   red[Let][Let](z, z', z'') -{ 0 }-> 1 + (1 + t1 + t2) + e2 :|: z = e, z' = 1 + t1 + t2, t1 >= 0, e >= 0, e2 >= 0, t2 >= 0, z'' = e2
   subst(z, z', z'') -{ 2 }-> subst[True][Ite](1, 1 + i1' + l1', a, 1 + var + exp) :|: i1' >= 0, z = 1 + i1' + l1', z' = a, var >= 0, l1' >= 0, a >= 0, z'' = 1 + var + exp, exp >= 0
   subst(z, z', z'') -{ 2 }-> subst[True][Ite](1, 1 + t11' + t12', a, 1 + var + exp) :|: z' = a, t11' >= 0, var >= 0, a >= 0, z'' = 1 + var + exp, z = 1 + t11' + t12', t12' >= 0, exp >= 0
   subst(z, z', z'') -{ 1 }-> subst[True][Ite](0, x, a, 1 + var + exp) :|: z' = a, var >= 0, a >= 0, z'' = 1 + var + exp, x >= 0, z = x, exp >= 0
   subst(z, z', z'') -{ 2 }-> subst[True][Ite](!EQ(v1', var), 1 + v1', a, 1 + var + exp) :|: z' = a, var >= 0, a >= 0, z'' = 1 + var + exp, v1' >= 0, z = 1 + v1', exp >= 0
   subst(z, z', z'') -{ 2 }-> subst[Ite](1, 1 + i1'' + l1'', a, 1 + int) :|: l1'' >= 0, z' = a, z'' = 1 + int, a >= 0, z = 1 + i1'' + l1'', i1'' >= 0, int >= 0
   subst(z, z', z'') -{ 2 }-> subst[Ite](1, 1 + t11'' + t12'', a, 1 + int) :|: t12'' >= 0, z' = a, z'' = 1 + int, z = 1 + t11'' + t12'', a >= 0, int >= 0, t11'' >= 0
   subst(z, z', z'') -{ 1 }-> subst[Ite](0, x, a, 1 + int) :|: z' = a, z'' = 1 + int, a >= 0, x >= 0, z = x, int >= 0
   subst(z, z', z'') -{ 2 }-> subst[Ite](!EQ(v1'', int), 1 + v1'', a, 1 + int) :|: z' = a, z'' = 1 + int, a >= 0, v1'' >= 0, z = 1 + v1'', int >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[True][Ite](eqTerm(x, 1 + var'), x, a, 1 + var' + exp'), subst[True][Ite](eqTerm(x, 1 + var1), x, a, 1 + var1 + exp1)) :|: z'' = 1 + (1 + var' + exp') + (1 + var1 + exp1), z' = a, exp' >= 0, a >= 0, var1 >= 0, x >= 0, exp1 >= 0, z = x, var' >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[True][Ite](eqTerm(x, 1 + var'), x, a, 1 + var' + exp'), subst[Ite](eqTerm(x, 1 + int1), x, a, 1 + int1)) :|: z' = a, z'' = 1 + (1 + var' + exp') + (1 + int1), exp' >= 0, a >= 0, x >= 0, int1 >= 0, z = x, var' >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[True][Ite](eqTerm(x, 1 + var'), x, a, 1 + var' + exp'), mkapp(subst(x, a, e11), subst(x, a, e21))) :|: z' = a, exp' >= 0, a >= 0, e21 >= 0, x >= 0, e11 >= 0, z = x, z'' = 1 + (1 + var' + exp') + (1 + e11 + e21), var' >= 0
   subst(z, z', z'') -{ 2 }-> mkapp(subst[True][Ite](eqTerm(x, 1 + var'), x, a, 1 + var' + exp'), 0) :|: z' = a, exp' >= 0, a >= 0, z'' = 1 + (1 + var' + exp') + e2, x >= 0, z = x, e2 >= 0, var' >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[Ite](eqTerm(x, 1 + int'), x, a, 1 + int'), subst[True][Ite](eqTerm(x, 1 + var2), x, a, 1 + var2 + exp2)) :|: int' >= 0, var2 >= 0, exp2 >= 0, z'' = 1 + (1 + int') + (1 + var2 + exp2), z' = a, a >= 0, x >= 0, z = x
   subst(z, z', z'') -{ 3 }-> mkapp(subst[Ite](eqTerm(x, 1 + int'), x, a, 1 + int'), subst[Ite](eqTerm(x, 1 + int2), x, a, 1 + int2)) :|: int' >= 0, z' = a, int2 >= 0, a >= 0, x >= 0, z'' = 1 + (1 + int') + (1 + int2), z = x
   subst(z, z', z'') -{ 3 }-> mkapp(subst[Ite](eqTerm(x, 1 + int'), x, a, 1 + int'), mkapp(subst(x, a, e12), subst(x, a, e22))) :|: int' >= 0, z' = a, a >= 0, x >= 0, e22 >= 0, z'' = 1 + (1 + int') + (1 + e12 + e22), e12 >= 0, z = x
   subst(z, z', z'') -{ 2 }-> mkapp(subst[Ite](eqTerm(x, 1 + int'), x, a, 1 + int'), 0) :|: z'' = 1 + (1 + int') + e2, int' >= 0, z' = a, a >= 0, x >= 0, z = x, e2 >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(mkapp(subst(x, a, e1'), subst(x, a, e2')), subst[True][Ite](eqTerm(x, 1 + var''), x, a, 1 + var'' + exp'')) :|: z' = a, e1' >= 0, exp'' >= 0, a >= 0, var'' >= 0, x >= 0, e2' >= 0, z = x, z'' = 1 + (1 + e1' + e2') + (1 + var'' + exp'')
   subst(z, z', z'') -{ 3 }-> mkapp(mkapp(subst(x, a, e1'), subst(x, a, e2')), subst[Ite](eqTerm(x, 1 + int''), x, a, 1 + int'')) :|: z' = a, e1' >= 0, a >= 0, x >= 0, z'' = 1 + (1 + e1' + e2') + (1 + int''), int'' >= 0, e2' >= 0, z = x
   subst(z, z', z'') -{ 3 }-> mkapp(mkapp(subst(x, a, e1'), subst(x, a, e2')), mkapp(subst(x, a, e1''), subst(x, a, e2''))) :|: z' = a, e1' >= 0, a >= 0, x >= 0, e1'' >= 0, z'' = 1 + (1 + e1' + e2') + (1 + e1'' + e2''), e2' >= 0, e2'' >= 0, z = x
   subst(z, z', z'') -{ 2 }-> mkapp(mkapp(subst(x, a, e1'), subst(x, a, e2')), 0) :|: z' = a, e1' >= 0, a >= 0, x >= 0, z'' = 1 + (1 + e1' + e2') + e2, e2' >= 0, z = x, e2 >= 0
   subst(z, z', z'') -{ 2 }-> mkapp(0, subst[True][Ite](eqTerm(x, 1 + var3), x, a, 1 + var3 + exp3)) :|: z' = a, z'' = 1 + e1 + (1 + var3 + exp3), a >= 0, var3 >= 0, exp3 >= 0, x >= 0, e1 >= 0, z = x
   subst(z, z', z'') -{ 2 }-> mkapp(0, subst[Ite](eqTerm(x, 1 + int3), x, a, 1 + int3)) :|: int3 >= 0, z' = a, a >= 0, z'' = 1 + e1 + (1 + int3), x >= 0, e1 >= 0, z = x
   subst(z, z', z'') -{ 2 }-> mkapp(0, mkapp(subst(x, a, e13), subst(x, a, e23))) :|: e13 >= 0, z' = a, z'' = 1 + e1 + (1 + e13 + e23), a >= 0, x >= 0, e1 >= 0, e23 >= 0, z = x
   subst(z, z', z'') -{ 1 }-> mkapp(0, 0) :|: z' = a, z'' = 1 + e1 + e2, a >= 0, x >= 0, e1 >= 0, z = x, e2 >= 0
   subst(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> a :|: z = 2, z' = x, z1 = e, a >= 0, z'' = a, x >= 0, e >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> e :|: z' = x, z1 = e, a >= 0, z = 1, z'' = a, x >= 0, e >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   subst[True][Ite](z, z', z'', z1) -{ 0 }-> e :|: z = 2, z' = x, z1 = e, a >= 0, z'' = a, x >= 0, e >= 0
   subst[True][Ite](z, z', z'', z1) -{ 1 }-> mklam(1 + var, subst[True][Ite](eqTerm(x, 1 + var5), x, a, 1 + var5 + exp5)) :|: z' = x, var >= 0, a >= 0, exp5 >= 0, z = 1, z'' = a, x >= 0, var5 >= 0, z1 = 1 + var + (1 + var5 + exp5)
   subst[True][Ite](z, z', z'', z1) -{ 1 }-> mklam(1 + var, subst[Ite](eqTerm(x, 1 + int7), x, a, 1 + int7)) :|: int7 >= 0, z' = x, var >= 0, a >= 0, z = 1, z'' = a, x >= 0, z1 = 1 + var + (1 + int7)
   subst[True][Ite](z, z', z'', z1) -{ 1 }-> mklam(1 + var, mkapp(subst(x, a, e16), subst(x, a, e26))) :|: z' = x, var >= 0, a >= 0, z = 1, z'' = a, x >= 0, e26 >= 0, e16 >= 0, z1 = 1 + var + (1 + e16 + e26)
   subst[True][Ite](z, z', z'', z1) -{ 0 }-> mklam(1 + var, 0) :|: z' = x, var >= 0, a >= 0, z = 1, z'' = a, x >= 0, z1 = 1 + var + exp, exp >= 0
   subst[True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0


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

(17) InliningProof (UPPER BOUND(ID))
Inlined the following terminating rules on right-hand sides where appropriate:

   mklam(z, z') -{ 1 }-> 1 + name + e :|: z' = e, z = 1 + name, e >= 0, name >= 0
   mklam(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   mkapp(z, z') -{ 1 }-> 1 + e1 + e2 :|: z' = e2, z = e1, e1 >= 0, e2 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   subst[Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> a :|: z = 2, z' = x, z1 = e, a >= 0, z'' = a, x >= 0, e >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> e :|: z' = x, z1 = e, a >= 0, z = 1, z'' = a, x >= 0, e >= 0

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

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

   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' = 1 + y, y >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: x >= 0, z = 1 + x, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   !EQ(z, z') -{ 0 }-> !EQ(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   appe1(z) -{ 1 }-> e1 :|: e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   appe2(z) -{ 1 }-> e2 :|: e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   eqTerm(z, z') -{ 1 }-> and(eqTerm(t11, t21), eqTerm(t12, t22)) :|: z' = 1 + t21 + t22, t11 >= 0, t21 >= 0, t12 >= 0, z = 1 + t11 + t12, t22 >= 0
   eqTerm(z, z') -{ 1 }-> and(!EQ(i1, i2), eqTerm(l1, l2)) :|: i1 >= 0, z' = 1 + i2 + l2, l1 >= 0, i2 >= 0, l2 >= 0, z = 1 + i1 + l1
   eqTerm(z, z') -{ 1 }-> 1 :|: z' = 1 + i2 + l2, t11 >= 0, t12 >= 0, i2 >= 0, l2 >= 0, z = 1 + t11 + t12
   eqTerm(z, z') -{ 1 }-> 1 :|: z' = 1 + v2, t11 >= 0, t12 >= 0, z = 1 + t11 + t12, v2 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: i1 >= 0, z' = 1 + t21 + t22, t21 >= 0, l1 >= 0, z = 1 + i1 + l1, t22 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: i1 >= 0, z' = 1 + v2, l1 >= 0, z = 1 + i1 + l1, v2 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: z = 1 + v1, z' = 1 + t21 + t22, v1 >= 0, t21 >= 0, t22 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: z = 1 + v1, z' = 1 + i2 + l2, v1 >= 0, i2 >= 0, l2 >= 0
   eqTerm(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   eqTerm(z, z') -{ 1 }-> !EQ(v1, v2) :|: z' = 1 + v2, z = 1 + v1, v1 >= 0, v2 >= 0
   islam(z) -{ 1 }-> 2 :|: term >= 0, z = 1 + int + term, int >= 0
   islam(z) -{ 1 }-> 1 :|: z = 1 + t1 + t2, t1 >= 0, t2 >= 0
   islam(z) -{ 1 }-> 1 :|: int >= 0, z = 1 + int
   isvar(z) -{ 1 }-> 2 :|: int >= 0, z = 1 + int
   isvar(z) -{ 1 }-> 1 :|: z = 1 + t1 + t2, t1 >= 0, t2 >= 0
   isvar(z) -{ 1 }-> 1 :|: term >= 0, z = 1 + int + term, int >= 0
   lambdaint(z) -{ 1 }-> red(e) :|: z = e, e >= 0
   lambody(z) -{ 1 }-> exp :|: var >= 0, z = 1 + var + exp, exp >= 0
   lamvar(z) -{ 1 }-> 1 + var :|: var >= 0, z = 1 + var + exp, exp >= 0
   mkapp(z, z') -{ 1 }-> 1 + e1 + e2 :|: z' = e2, z = e1, e1 >= 0, e2 >= 0
   mklam(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   mklam(z, z') -{ 1 }-> 1 + name + e :|: z' = e, z = 1 + name, e >= 0, name >= 0
   red(z) -{ 1 }-> red[Let](1 + e1 + e2, 0) :|: e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   red(z) -{ 2 }-> red[Let](1 + (1 + int5) + e2, 1 + int5) :|: z = 1 + (1 + int5) + e2, int5 >= 0, e2 >= 0
   red(z) -{ 2 }-> red[Let](1 + (1 + e14 + e24) + e2, red[Let](1 + e14 + e24, red(e14))) :|: e24 >= 0, z = 1 + (1 + e14 + e24) + e2, e2 >= 0, e14 >= 0
   red(z) -{ 2 }-> red[Let](1 + (1 + int4 + term') + e2, 1 + int4 + term') :|: term' >= 0, int4 >= 0, z = 1 + (1 + int4 + term') + e2, e2 >= 0
   red(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   red(z) -{ 1 }-> 1 + int :|: int >= 0, z = 1 + int
   red(z) -{ 1 }-> 1 + int + term :|: term >= 0, z = 1 + int + term, int >= 0
   red[Let](z, z') -{ 0 }-> red[Let][Let](1 + e1 + e2, f, 0) :|: f >= 0, z' = f, e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   red[Let](z, z') -{ 1 }-> red[Let][Let](1 + e1 + (1 + int9), f, 1 + int9) :|: f >= 0, z = 1 + e1 + (1 + int9), z' = f, int9 >= 0, e1 >= 0
   red[Let](z, z') -{ 1 }-> red[Let][Let](1 + e1 + (1 + e17 + e27), f, red[Let](1 + e17 + e27, red(e17))) :|: f >= 0, e17 >= 0, e27 >= 0, z' = f, z = 1 + e1 + (1 + e17 + e27), e1 >= 0
   red[Let](z, z') -{ 1 }-> red[Let][Let](1 + e1 + (1 + int8 + term''), f, 1 + int8 + term'') :|: z = 1 + e1 + (1 + int8 + term''), f >= 0, term'' >= 0, z' = f, e1 >= 0, int8 >= 0
   red[Let](z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   red[Let][Let](z, z', z'') -{ 1 }-> red(subst[True][Ite](eqTerm(1 + var, 1 + var4), 1 + var, a, 1 + var4 + exp4)) :|: z = e, var >= 0, a >= 0, z'' = a, z' = 1 + var + (1 + var4 + exp4), var4 >= 0, exp4 >= 0, e >= 0
   red[Let][Let](z, z', z'') -{ 1 }-> red(subst[Ite](eqTerm(1 + var, 1 + int6), 1 + var, a, 1 + int6)) :|: z = e, var >= 0, int6 >= 0, a >= 0, z'' = a, e >= 0, z' = 1 + var + (1 + int6)
   red[Let][Let](z, z', z'') -{ 1 }-> red(mkapp(subst(1 + var, a, e15), subst(1 + var, a, e25))) :|: z = e, var >= 0, a >= 0, z'' = a, z' = 1 + var + (1 + e15 + e25), e >= 0, e25 >= 0, e15 >= 0
   red[Let][Let](z, z', z'') -{ 0 }-> red(0) :|: z = e, var >= 0, a >= 0, z'' = a, z' = 1 + var + exp, e >= 0, exp >= 0
   red[Let][Let](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   red[Let][Let](z, z', z'') -{ 0 }-> 1 + (1 + int) + e2 :|: z = e, e >= 0, int >= 0, e2 >= 0, z' = 1 + int, z'' = e2
   red[Let][Let](z, z', z'') -{ 0 }-> 1 + (1 + t1 + t2) + e2 :|: z = e, z' = 1 + t1 + t2, t1 >= 0, e >= 0, e2 >= 0, t2 >= 0, z'' = e2
   subst(z, z', z'') -{ 2 }-> e :|: t12'' >= 0, z' = a, z'' = 1 + int, z = 1 + t11'' + t12'', a >= 0, int >= 0, t11'' >= 0, 1 + t11'' + t12'' = x, 1 + int = e, a' >= 0, 1 = 1, a = a', x >= 0, e >= 0
   subst(z, z', z'') -{ 2 }-> e :|: l1'' >= 0, z' = a, z'' = 1 + int, a >= 0, z = 1 + i1'' + l1'', i1'' >= 0, int >= 0, 1 + i1'' + l1'' = x, 1 + int = e, a' >= 0, 1 = 1, a = a', x >= 0, e >= 0
   subst(z, z', z'') -{ 2 }-> subst[True][Ite](1, 1 + i1' + l1', a, 1 + var + exp) :|: i1' >= 0, z = 1 + i1' + l1', z' = a, var >= 0, l1' >= 0, a >= 0, z'' = 1 + var + exp, exp >= 0
   subst(z, z', z'') -{ 2 }-> subst[True][Ite](1, 1 + t11' + t12', a, 1 + var + exp) :|: z' = a, t11' >= 0, var >= 0, a >= 0, z'' = 1 + var + exp, z = 1 + t11' + t12', t12' >= 0, exp >= 0
   subst(z, z', z'') -{ 1 }-> subst[True][Ite](0, x, a, 1 + var + exp) :|: z' = a, var >= 0, a >= 0, z'' = 1 + var + exp, x >= 0, z = x, exp >= 0
   subst(z, z', z'') -{ 2 }-> subst[True][Ite](!EQ(v1', var), 1 + v1', a, 1 + var + exp) :|: z' = a, var >= 0, a >= 0, z'' = 1 + var + exp, v1' >= 0, z = 1 + v1', exp >= 0
   subst(z, z', z'') -{ 2 }-> subst[Ite](!EQ(v1'', int), 1 + v1'', a, 1 + int) :|: z' = a, z'' = 1 + int, a >= 0, v1'' >= 0, z = 1 + v1'', int >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[True][Ite](eqTerm(x, 1 + var'), x, a, 1 + var' + exp'), subst[True][Ite](eqTerm(x, 1 + var1), x, a, 1 + var1 + exp1)) :|: z'' = 1 + (1 + var' + exp') + (1 + var1 + exp1), z' = a, exp' >= 0, a >= 0, var1 >= 0, x >= 0, exp1 >= 0, z = x, var' >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[True][Ite](eqTerm(x, 1 + var'), x, a, 1 + var' + exp'), subst[Ite](eqTerm(x, 1 + int1), x, a, 1 + int1)) :|: z' = a, z'' = 1 + (1 + var' + exp') + (1 + int1), exp' >= 0, a >= 0, x >= 0, int1 >= 0, z = x, var' >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[True][Ite](eqTerm(x, 1 + var'), x, a, 1 + var' + exp'), mkapp(subst(x, a, e11), subst(x, a, e21))) :|: z' = a, exp' >= 0, a >= 0, e21 >= 0, x >= 0, e11 >= 0, z = x, z'' = 1 + (1 + var' + exp') + (1 + e11 + e21), var' >= 0
   subst(z, z', z'') -{ 2 }-> mkapp(subst[True][Ite](eqTerm(x, 1 + var'), x, a, 1 + var' + exp'), 0) :|: z' = a, exp' >= 0, a >= 0, z'' = 1 + (1 + var' + exp') + e2, x >= 0, z = x, e2 >= 0, var' >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[Ite](eqTerm(x, 1 + int'), x, a, 1 + int'), subst[True][Ite](eqTerm(x, 1 + var2), x, a, 1 + var2 + exp2)) :|: int' >= 0, var2 >= 0, exp2 >= 0, z'' = 1 + (1 + int') + (1 + var2 + exp2), z' = a, a >= 0, x >= 0, z = x
   subst(z, z', z'') -{ 3 }-> mkapp(subst[Ite](eqTerm(x, 1 + int'), x, a, 1 + int'), subst[Ite](eqTerm(x, 1 + int2), x, a, 1 + int2)) :|: int' >= 0, z' = a, int2 >= 0, a >= 0, x >= 0, z'' = 1 + (1 + int') + (1 + int2), z = x
   subst(z, z', z'') -{ 3 }-> mkapp(subst[Ite](eqTerm(x, 1 + int'), x, a, 1 + int'), mkapp(subst(x, a, e12), subst(x, a, e22))) :|: int' >= 0, z' = a, a >= 0, x >= 0, e22 >= 0, z'' = 1 + (1 + int') + (1 + e12 + e22), e12 >= 0, z = x
   subst(z, z', z'') -{ 2 }-> mkapp(subst[Ite](eqTerm(x, 1 + int'), x, a, 1 + int'), 0) :|: z'' = 1 + (1 + int') + e2, int' >= 0, z' = a, a >= 0, x >= 0, z = x, e2 >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(mkapp(subst(x, a, e1'), subst(x, a, e2')), subst[True][Ite](eqTerm(x, 1 + var''), x, a, 1 + var'' + exp'')) :|: z' = a, e1' >= 0, exp'' >= 0, a >= 0, var'' >= 0, x >= 0, e2' >= 0, z = x, z'' = 1 + (1 + e1' + e2') + (1 + var'' + exp'')
   subst(z, z', z'') -{ 3 }-> mkapp(mkapp(subst(x, a, e1'), subst(x, a, e2')), subst[Ite](eqTerm(x, 1 + int''), x, a, 1 + int'')) :|: z' = a, e1' >= 0, a >= 0, x >= 0, z'' = 1 + (1 + e1' + e2') + (1 + int''), int'' >= 0, e2' >= 0, z = x
   subst(z, z', z'') -{ 3 }-> mkapp(mkapp(subst(x, a, e1'), subst(x, a, e2')), mkapp(subst(x, a, e1''), subst(x, a, e2''))) :|: z' = a, e1' >= 0, a >= 0, x >= 0, e1'' >= 0, z'' = 1 + (1 + e1' + e2') + (1 + e1'' + e2''), e2' >= 0, e2'' >= 0, z = x
   subst(z, z', z'') -{ 2 }-> mkapp(mkapp(subst(x, a, e1'), subst(x, a, e2')), 0) :|: z' = a, e1' >= 0, a >= 0, x >= 0, z'' = 1 + (1 + e1' + e2') + e2, e2' >= 0, z = x, e2 >= 0
   subst(z, z', z'') -{ 2 }-> mkapp(0, subst[True][Ite](eqTerm(x, 1 + var3), x, a, 1 + var3 + exp3)) :|: z' = a, z'' = 1 + e1 + (1 + var3 + exp3), a >= 0, var3 >= 0, exp3 >= 0, x >= 0, e1 >= 0, z = x
   subst(z, z', z'') -{ 2 }-> mkapp(0, subst[Ite](eqTerm(x, 1 + int3), x, a, 1 + int3)) :|: int3 >= 0, z' = a, a >= 0, z'' = 1 + e1 + (1 + int3), x >= 0, e1 >= 0, z = x
   subst(z, z', z'') -{ 2 }-> mkapp(0, mkapp(subst(x, a, e13), subst(x, a, e23))) :|: e13 >= 0, z' = a, z'' = 1 + e1 + (1 + e13 + e23), a >= 0, x >= 0, e1 >= 0, e23 >= 0, z = x
   subst(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   subst(z, z', z'') -{ 2 }-> 0 :|: t12'' >= 0, z' = a, z'' = 1 + int, z = 1 + t11'' + t12'', a >= 0, int >= 0, t11'' >= 0, 1 + int = v3, v0 >= 0, a = v2, v1 >= 0, 1 = v0, 1 + t11'' + t12'' = v1, v2 >= 0, v3 >= 0
   subst(z, z', z'') -{ 2 }-> 0 :|: l1'' >= 0, z' = a, z'' = 1 + int, a >= 0, z = 1 + i1'' + l1'', i1'' >= 0, int >= 0, 1 + int = v3, v0 >= 0, a = v2, v1 >= 0, 1 = v0, 1 + i1'' + l1'' = v1, v2 >= 0, v3 >= 0
   subst(z, z', z'') -{ 1 }-> 0 :|: z' = a, z'' = 1 + int, a >= 0, x >= 0, z = x, int >= 0, 1 + int = v3, v0 >= 0, a = v2, v1 >= 0, 0 = v0, x = v1, v2 >= 0, v3 >= 0
   subst(z, z', z'') -{ 2 }-> 1 + e1' + e2' :|: z' = a, z'' = 1 + e1 + e2, a >= 0, x >= 0, e1 >= 0, z = x, e2 >= 0, 0 = e2', 0 = e1', e1' >= 0, e2' >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> a :|: z = 2, z' = x, z1 = e, a >= 0, z'' = a, x >= 0, e >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> e :|: z' = x, z1 = e, a >= 0, z = 1, z'' = a, x >= 0, e >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   subst[True][Ite](z, z', z'', z1) -{ 0 }-> e :|: z = 2, z' = x, z1 = e, a >= 0, z'' = a, x >= 0, e >= 0
   subst[True][Ite](z, z', z'', z1) -{ 1 }-> mklam(1 + var, subst[True][Ite](eqTerm(x, 1 + var5), x, a, 1 + var5 + exp5)) :|: z' = x, var >= 0, a >= 0, exp5 >= 0, z = 1, z'' = a, x >= 0, var5 >= 0, z1 = 1 + var + (1 + var5 + exp5)
   subst[True][Ite](z, z', z'', z1) -{ 1 }-> mklam(1 + var, subst[Ite](eqTerm(x, 1 + int7), x, a, 1 + int7)) :|: int7 >= 0, z' = x, var >= 0, a >= 0, z = 1, z'' = a, x >= 0, z1 = 1 + var + (1 + int7)
   subst[True][Ite](z, z', z'', z1) -{ 1 }-> mklam(1 + var, mkapp(subst(x, a, e16), subst(x, a, e26))) :|: z' = x, var >= 0, a >= 0, z = 1, z'' = a, x >= 0, e26 >= 0, e16 >= 0, z1 = 1 + var + (1 + e16 + e26)
   subst[True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   subst[True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z' = x, var >= 0, a >= 0, z = 1, z'' = a, x >= 0, z1 = 1 + var + exp, exp >= 0, v0 >= 0, v1 >= 0, 1 + var = v0, 0 = v1
   subst[True][Ite](z, z', z'', z1) -{ 1 }-> 1 + name + e :|: z' = x, var >= 0, a >= 0, z = 1, z'' = a, x >= 0, z1 = 1 + var + exp, exp >= 0, 0 = e, 1 + var = 1 + name, e >= 0, name >= 0


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

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

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

   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' - 1 >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z - 1 >= 0, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   !EQ(z, z') -{ 0 }-> !EQ(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   appe1(z) -{ 1 }-> e1 :|: e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   appe2(z) -{ 1 }-> e2 :|: e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   eqTerm(z, z') -{ 1 }-> and(eqTerm(t11, t21), eqTerm(t12, t22)) :|: z' = 1 + t21 + t22, t11 >= 0, t21 >= 0, t12 >= 0, z = 1 + t11 + t12, t22 >= 0
   eqTerm(z, z') -{ 1 }-> and(!EQ(i1, i2), eqTerm(l1, l2)) :|: i1 >= 0, z' = 1 + i2 + l2, l1 >= 0, i2 >= 0, l2 >= 0, z = 1 + i1 + l1
   eqTerm(z, z') -{ 1 }-> 1 :|: z' = 1 + i2 + l2, t11 >= 0, t12 >= 0, i2 >= 0, l2 >= 0, z = 1 + t11 + t12
   eqTerm(z, z') -{ 1 }-> 1 :|: t11 >= 0, t12 >= 0, z = 1 + t11 + t12, z' - 1 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: i1 >= 0, z' = 1 + t21 + t22, t21 >= 0, l1 >= 0, z = 1 + i1 + l1, t22 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: i1 >= 0, l1 >= 0, z = 1 + i1 + l1, z' - 1 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: z' = 1 + t21 + t22, z - 1 >= 0, t21 >= 0, t22 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: z' = 1 + i2 + l2, z - 1 >= 0, i2 >= 0, l2 >= 0
   eqTerm(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   eqTerm(z, z') -{ 1 }-> !EQ(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   islam(z) -{ 1 }-> 2 :|: term >= 0, z = 1 + int + term, int >= 0
   islam(z) -{ 1 }-> 1 :|: z = 1 + t1 + t2, t1 >= 0, t2 >= 0
   islam(z) -{ 1 }-> 1 :|: z - 1 >= 0
   isvar(z) -{ 1 }-> 2 :|: z - 1 >= 0
   isvar(z) -{ 1 }-> 1 :|: z = 1 + t1 + t2, t1 >= 0, t2 >= 0
   isvar(z) -{ 1 }-> 1 :|: term >= 0, z = 1 + int + term, int >= 0
   lambdaint(z) -{ 1 }-> red(z) :|: z >= 0
   lambody(z) -{ 1 }-> exp :|: var >= 0, z = 1 + var + exp, exp >= 0
   lamvar(z) -{ 1 }-> 1 + var :|: var >= 0, z = 1 + var + exp, exp >= 0
   mkapp(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   mklam(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   mklam(z, z') -{ 1 }-> 1 + (z - 1) + z' :|: z' >= 0, z - 1 >= 0
   red(z) -{ 1 }-> red[Let](1 + e1 + e2, 0) :|: e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   red(z) -{ 2 }-> red[Let](1 + (1 + int5) + e2, 1 + int5) :|: z = 1 + (1 + int5) + e2, int5 >= 0, e2 >= 0
   red(z) -{ 2 }-> red[Let](1 + (1 + e14 + e24) + e2, red[Let](1 + e14 + e24, red(e14))) :|: e24 >= 0, z = 1 + (1 + e14 + e24) + e2, e2 >= 0, e14 >= 0
   red(z) -{ 2 }-> red[Let](1 + (1 + int4 + term') + e2, 1 + int4 + term') :|: term' >= 0, int4 >= 0, z = 1 + (1 + int4 + term') + e2, e2 >= 0
   red(z) -{ 0 }-> 0 :|: z >= 0
   red(z) -{ 1 }-> 1 + (z - 1) :|: z - 1 >= 0
   red(z) -{ 1 }-> 1 + int + term :|: term >= 0, z = 1 + int + term, int >= 0
   red[Let](z, z') -{ 0 }-> red[Let][Let](1 + e1 + e2, z', 0) :|: z' >= 0, e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   red[Let](z, z') -{ 1 }-> red[Let][Let](1 + e1 + (1 + int9), z', 1 + int9) :|: z' >= 0, z = 1 + e1 + (1 + int9), int9 >= 0, e1 >= 0
   red[Let](z, z') -{ 1 }-> red[Let][Let](1 + e1 + (1 + e17 + e27), z', red[Let](1 + e17 + e27, red(e17))) :|: z' >= 0, e17 >= 0, e27 >= 0, z = 1 + e1 + (1 + e17 + e27), e1 >= 0
   red[Let](z, z') -{ 1 }-> red[Let][Let](1 + e1 + (1 + int8 + term''), z', 1 + int8 + term'') :|: z = 1 + e1 + (1 + int8 + term''), z' >= 0, term'' >= 0, e1 >= 0, int8 >= 0
   red[Let](z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   red[Let][Let](z, z', z'') -{ 1 }-> red(subst[True][Ite](eqTerm(1 + var, 1 + var4), 1 + var, z'', 1 + var4 + exp4)) :|: var >= 0, z'' >= 0, z' = 1 + var + (1 + var4 + exp4), var4 >= 0, exp4 >= 0, z >= 0
   red[Let][Let](z, z', z'') -{ 1 }-> red(subst[Ite](eqTerm(1 + var, 1 + int6), 1 + var, z'', 1 + int6)) :|: var >= 0, int6 >= 0, z'' >= 0, z >= 0, z' = 1 + var + (1 + int6)
   red[Let][Let](z, z', z'') -{ 1 }-> red(mkapp(subst(1 + var, z'', e15), subst(1 + var, z'', e25))) :|: var >= 0, z'' >= 0, z' = 1 + var + (1 + e15 + e25), z >= 0, e25 >= 0, e15 >= 0
   red[Let][Let](z, z', z'') -{ 0 }-> red(0) :|: var >= 0, z'' >= 0, z' = 1 + var + exp, z >= 0, exp >= 0
   red[Let][Let](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   red[Let][Let](z, z', z'') -{ 0 }-> 1 + (1 + (z' - 1)) + z'' :|: z >= 0, z' - 1 >= 0, z'' >= 0
   red[Let][Let](z, z', z'') -{ 0 }-> 1 + (1 + t1 + t2) + z'' :|: z' = 1 + t1 + t2, t1 >= 0, z >= 0, z'' >= 0, t2 >= 0
   subst(z, z', z'') -{ 2 }-> e :|: t12'' >= 0, z = 1 + t11'' + t12'', z' >= 0, z'' - 1 >= 0, t11'' >= 0, 1 + t11'' + t12'' = x, 1 + (z'' - 1) = e, 1 = 1, x >= 0, e >= 0
   subst(z, z', z'') -{ 2 }-> e :|: l1'' >= 0, z' >= 0, z = 1 + i1'' + l1'', i1'' >= 0, z'' - 1 >= 0, 1 + i1'' + l1'' = x, 1 + (z'' - 1) = e, 1 = 1, x >= 0, e >= 0
   subst(z, z', z'') -{ 2 }-> subst[True][Ite](1, 1 + i1' + l1', z', 1 + var + exp) :|: i1' >= 0, z = 1 + i1' + l1', var >= 0, l1' >= 0, z' >= 0, z'' = 1 + var + exp, exp >= 0
   subst(z, z', z'') -{ 2 }-> subst[True][Ite](1, 1 + t11' + t12', z', 1 + var + exp) :|: t11' >= 0, var >= 0, z' >= 0, z'' = 1 + var + exp, z = 1 + t11' + t12', t12' >= 0, exp >= 0
   subst(z, z', z'') -{ 1 }-> subst[True][Ite](0, z, z', 1 + var + exp) :|: var >= 0, z' >= 0, z'' = 1 + var + exp, z >= 0, exp >= 0
   subst(z, z', z'') -{ 2 }-> subst[True][Ite](!EQ(z - 1, var), 1 + (z - 1), z', 1 + var + exp) :|: var >= 0, z' >= 0, z'' = 1 + var + exp, z - 1 >= 0, exp >= 0
   subst(z, z', z'') -{ 2 }-> subst[Ite](!EQ(z - 1, z'' - 1), 1 + (z - 1), z', 1 + (z'' - 1)) :|: z' >= 0, z - 1 >= 0, z'' - 1 >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[True][Ite](eqTerm(z, 1 + var'), z, z', 1 + var' + exp'), subst[True][Ite](eqTerm(z, 1 + var1), z, z', 1 + var1 + exp1)) :|: z'' = 1 + (1 + var' + exp') + (1 + var1 + exp1), exp' >= 0, z' >= 0, var1 >= 0, z >= 0, exp1 >= 0, var' >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[True][Ite](eqTerm(z, 1 + var'), z, z', 1 + var' + exp'), subst[Ite](eqTerm(z, 1 + int1), z, z', 1 + int1)) :|: z'' = 1 + (1 + var' + exp') + (1 + int1), exp' >= 0, z' >= 0, z >= 0, int1 >= 0, var' >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[True][Ite](eqTerm(z, 1 + var'), z, z', 1 + var' + exp'), mkapp(subst(z, z', e11), subst(z, z', e21))) :|: exp' >= 0, z' >= 0, e21 >= 0, z >= 0, e11 >= 0, z'' = 1 + (1 + var' + exp') + (1 + e11 + e21), var' >= 0
   subst(z, z', z'') -{ 2 }-> mkapp(subst[True][Ite](eqTerm(z, 1 + var'), z, z', 1 + var' + exp'), 0) :|: exp' >= 0, z' >= 0, z'' = 1 + (1 + var' + exp') + e2, z >= 0, e2 >= 0, var' >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[Ite](eqTerm(z, 1 + int'), z, z', 1 + int'), subst[True][Ite](eqTerm(z, 1 + var2), z, z', 1 + var2 + exp2)) :|: int' >= 0, var2 >= 0, exp2 >= 0, z'' = 1 + (1 + int') + (1 + var2 + exp2), z' >= 0, z >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(subst[Ite](eqTerm(z, 1 + int'), z, z', 1 + int'), subst[Ite](eqTerm(z, 1 + int2), z, z', 1 + int2)) :|: int' >= 0, int2 >= 0, z' >= 0, z >= 0, z'' = 1 + (1 + int') + (1 + int2)
   subst(z, z', z'') -{ 3 }-> mkapp(subst[Ite](eqTerm(z, 1 + int'), z, z', 1 + int'), mkapp(subst(z, z', e12), subst(z, z', e22))) :|: int' >= 0, z' >= 0, z >= 0, e22 >= 0, z'' = 1 + (1 + int') + (1 + e12 + e22), e12 >= 0
   subst(z, z', z'') -{ 2 }-> mkapp(subst[Ite](eqTerm(z, 1 + int'), z, z', 1 + int'), 0) :|: z'' = 1 + (1 + int') + e2, int' >= 0, z' >= 0, z >= 0, e2 >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(mkapp(subst(z, z', e1'), subst(z, z', e2')), subst[True][Ite](eqTerm(z, 1 + var''), z, z', 1 + var'' + exp'')) :|: e1' >= 0, exp'' >= 0, z' >= 0, var'' >= 0, z >= 0, e2' >= 0, z'' = 1 + (1 + e1' + e2') + (1 + var'' + exp'')
   subst(z, z', z'') -{ 3 }-> mkapp(mkapp(subst(z, z', e1'), subst(z, z', e2')), subst[Ite](eqTerm(z, 1 + int''), z, z', 1 + int'')) :|: e1' >= 0, z' >= 0, z >= 0, z'' = 1 + (1 + e1' + e2') + (1 + int''), int'' >= 0, e2' >= 0
   subst(z, z', z'') -{ 3 }-> mkapp(mkapp(subst(z, z', e1'), subst(z, z', e2')), mkapp(subst(z, z', e1''), subst(z, z', e2''))) :|: e1' >= 0, z' >= 0, z >= 0, e1'' >= 0, z'' = 1 + (1 + e1' + e2') + (1 + e1'' + e2''), e2' >= 0, e2'' >= 0
   subst(z, z', z'') -{ 2 }-> mkapp(mkapp(subst(z, z', e1'), subst(z, z', e2')), 0) :|: e1' >= 0, z' >= 0, z >= 0, z'' = 1 + (1 + e1' + e2') + e2, e2' >= 0, e2 >= 0
   subst(z, z', z'') -{ 2 }-> mkapp(0, subst[True][Ite](eqTerm(z, 1 + var3), z, z', 1 + var3 + exp3)) :|: z'' = 1 + e1 + (1 + var3 + exp3), z' >= 0, var3 >= 0, exp3 >= 0, z >= 0, e1 >= 0
   subst(z, z', z'') -{ 2 }-> mkapp(0, subst[Ite](eqTerm(z, 1 + int3), z, z', 1 + int3)) :|: int3 >= 0, z' >= 0, z'' = 1 + e1 + (1 + int3), z >= 0, e1 >= 0
   subst(z, z', z'') -{ 2 }-> mkapp(0, mkapp(subst(z, z', e13), subst(z, z', e23))) :|: e13 >= 0, z'' = 1 + e1 + (1 + e13 + e23), z' >= 0, z >= 0, e1 >= 0, e23 >= 0
   subst(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   subst(z, z', z'') -{ 2 }-> 0 :|: t12'' >= 0, z = 1 + t11'' + t12'', z' >= 0, z'' - 1 >= 0, t11'' >= 0, 1 + (z'' - 1) = v3, v0 >= 0, v1 >= 0, 1 = v0, 1 + t11'' + t12'' = v1, v3 >= 0
   subst(z, z', z'') -{ 2 }-> 0 :|: l1'' >= 0, z' >= 0, z = 1 + i1'' + l1'', i1'' >= 0, z'' - 1 >= 0, 1 + (z'' - 1) = v3, v0 >= 0, v1 >= 0, 1 = v0, 1 + i1'' + l1'' = v1, v3 >= 0
   subst(z, z', z'') -{ 1 }-> 0 :|: z' >= 0, z >= 0, z'' - 1 >= 0, 1 + (z'' - 1) = v3, v0 >= 0, 0 = v0, v3 >= 0
   subst(z, z', z'') -{ 2 }-> 1 + e1' + e2' :|: z'' = 1 + e1 + e2, z' >= 0, z >= 0, e1 >= 0, e2 >= 0, 0 = e2', 0 = e1', e1' >= 0, e2' >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> z'' :|: z = 2, z'' >= 0, z' >= 0, z1 >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> z1 :|: z'' >= 0, z = 1, z' >= 0, z1 >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   subst[True][Ite](z, z', z'', z1) -{ 0 }-> z1 :|: z = 2, z'' >= 0, z' >= 0, z1 >= 0
   subst[True][Ite](z, z', z'', z1) -{ 1 }-> mklam(1 + var, subst[True][Ite](eqTerm(z', 1 + var5), z', z'', 1 + var5 + exp5)) :|: var >= 0, z'' >= 0, exp5 >= 0, z = 1, z' >= 0, var5 >= 0, z1 = 1 + var + (1 + var5 + exp5)
   subst[True][Ite](z, z', z'', z1) -{ 1 }-> mklam(1 + var, subst[Ite](eqTerm(z', 1 + int7), z', z'', 1 + int7)) :|: int7 >= 0, var >= 0, z'' >= 0, z = 1, z' >= 0, z1 = 1 + var + (1 + int7)
   subst[True][Ite](z, z', z'', z1) -{ 1 }-> mklam(1 + var, mkapp(subst(z', z'', e16), subst(z', z'', e26))) :|: var >= 0, z'' >= 0, z = 1, z' >= 0, e26 >= 0, e16 >= 0, z1 = 1 + var + (1 + e16 + e26)
   subst[True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0, z1 >= 0
   subst[True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: var >= 0, z'' >= 0, z = 1, z' >= 0, z1 = 1 + var + exp, exp >= 0, v0 >= 0, v1 >= 0, 1 + var = v0, 0 = v1
   subst[True][Ite](z, z', z'', z1) -{ 1 }-> 1 + name + e :|: var >= 0, z'' >= 0, z = 1, z' >= 0, z1 = 1 + var + exp, exp >= 0, 0 = e, 1 + var = 1 + name, e >= 0, name >= 0


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

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

   and(v0, v1) -> null_and [0]
   !EQ(v0, v1) -> null_!EQ [0]
   red[Let][Let](v0, v1, v2) -> null_red[Let][Let] [0]
   subst[True][Ite](v0, v1, v2, v3) -> null_subst[True][Ite] [0]
   red[Let](v0, v1) -> null_red[Let] [0]
   subst[Ite](v0, v1, v2, v3) -> null_subst[Ite] [0]
   subst(v0, v1, v2) -> null_subst [0]
   red(v0) -> null_red [0]
   eqTerm(v0, v1) -> null_eqTerm [0]
   mklam(v0, v1) -> null_mklam [0]
   lamvar(v0) -> null_lamvar [0]
   lambody(v0) -> null_lambody [0]
   isvar(v0) -> null_isvar [0]
   islam(v0) -> null_islam [0]
   appe2(v0) -> null_appe2 [0]
   appe1(v0) -> null_appe1 [0]

And the following fresh constants:    null_and, null_!EQ, null_red[Let][Let], null_subst[True][Ite], null_red[Let], null_subst[Ite], null_subst, null_red, null_eqTerm, null_mklam, null_lamvar, null_lambody, null_isvar, null_islam, null_appe2, null_appe1

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

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

   subst(x, a, App(e1, e2)) -> mkapp(subst(x, a, e1), subst(x, a, e2)) [1]
   subst(x, a, Lam(var, exp)) -> subst[True][Ite](eqTerm(x, V(var)), x, a, Lam(var, exp)) [1]
   red(App(e1, e2)) -> red[Let](App(e1, e2), red(e1)) [1]
   red(Lam(int, term)) -> Lam(int, term) [1]
   subst(x, a, V(int)) -> subst[Ite](eqTerm(x, V(int)), x, a, V(int)) [1]
   red(V(int)) -> V(int) [1]
   eqTerm(App(t11, t12), App(t21, t22)) -> and(eqTerm(t11, t21), eqTerm(t12, t22)) [1]
   eqTerm(App(t11, t12), Lam(i2, l2)) -> False [1]
   eqTerm(App(t11, t12), V(v2)) -> False [1]
   eqTerm(Lam(i1, l1), App(t21, t22)) -> False [1]
   eqTerm(Lam(i1, l1), Lam(i2, l2)) -> and(!EQ(i1, i2), eqTerm(l1, l2)) [1]
   eqTerm(Lam(i1, l1), V(v2)) -> False [1]
   eqTerm(V(v1), App(t21, t22)) -> False [1]
   eqTerm(V(v1), Lam(i2, l2)) -> False [1]
   eqTerm(V(v1), V(v2)) -> !EQ(v1, v2) [1]
   mklam(V(name), e) -> Lam(name, e) [1]
   lamvar(Lam(var, exp)) -> V(var) [1]
   lambody(Lam(var, exp)) -> exp [1]
   isvar(App(t1, t2)) -> False [1]
   isvar(Lam(int, term)) -> False [1]
   isvar(V(int)) -> True [1]
   islam(App(t1, t2)) -> False [1]
   islam(Lam(int, term)) -> True [1]
   islam(V(int)) -> False [1]
   appe2(App(e1, e2)) -> e2 [1]
   appe1(App(e1, e2)) -> e1 [1]
   mkapp(e1, e2) -> App(e1, e2) [1]
   lambdaint(e) -> red(e) [1]
   and(False, False) -> False [0]
   and(True, False) -> False [0]
   and(False, True) -> False [0]
   and(True, True) -> True [0]
   !EQ(S(x), S(y)) -> !EQ(x, y) [0]
   !EQ(0, S(y)) -> False [0]
   !EQ(S(x), 0) -> False [0]
   !EQ(0, 0) -> True [0]
   red[Let][Let](e, Lam(var, exp), a) -> red(subst(V(var), a, exp)) [0]
   subst[True][Ite](False, x, a, Lam(var, exp)) -> mklam(V(var), subst(x, a, exp)) [0]
   red[Let][Let](e, App(t1, t2), e2) -> App(App(t1, t2), e2) [0]
   red[Let][Let](e, V(int), e2) -> App(V(int), e2) [0]
   red[Let](App(e1, e2), f) -> red[Let][Let](App(e1, e2), f, red(e2)) [0]
   subst[True][Ite](True, x, a, e) -> e [0]
   subst[Ite](False, x, a, e) -> e [0]
   subst[Ite](True, x, a, e) -> a [0]
   and(v0, v1) -> null_and [0]
   !EQ(v0, v1) -> null_!EQ [0]
   red[Let][Let](v0, v1, v2) -> null_red[Let][Let] [0]
   subst[True][Ite](v0, v1, v2, v3) -> null_subst[True][Ite] [0]
   red[Let](v0, v1) -> null_red[Let] [0]
   subst[Ite](v0, v1, v2, v3) -> null_subst[Ite] [0]
   subst(v0, v1, v2) -> null_subst [0]
   red(v0) -> null_red [0]
   eqTerm(v0, v1) -> null_eqTerm [0]
   mklam(v0, v1) -> null_mklam [0]
   lamvar(v0) -> null_lamvar [0]
   lambody(v0) -> null_lambody [0]
   isvar(v0) -> null_isvar [0]
   islam(v0) -> null_islam [0]
   appe2(v0) -> null_appe2 [0]
   appe1(v0) -> null_appe1 [0]

The TRS has the following type information:
subst :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
App :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
mkapp :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
Lam :: S:0 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
subst[True][Ite] :: False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
eqTerm :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam
V :: S:0 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
red :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
red[Let] :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
subst[Ite] :: False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
and :: False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam -> False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam -> False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam
False :: False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam
!EQ :: S:0 -> S:0 -> False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam
mklam :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
lamvar :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
lambody :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
isvar :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam
True :: False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam
islam :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam
appe2 :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
appe1 :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
lambdaint :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
S :: S:0 -> S:0
0 :: S:0
red[Let][Let] :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1 -> App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
null_and :: False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam
null_!EQ :: False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam
null_red[Let][Let] :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
null_subst[True][Ite] :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
null_red[Let] :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
null_subst[Ite] :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
null_subst :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
null_red :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
null_eqTerm :: False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam
null_mklam :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
null_lamvar :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
null_lambody :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
null_isvar :: False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam
null_islam :: False:True:null_and:null_!EQ:null_eqTerm:null_isvar:null_islam
null_appe2 :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1
null_appe1 :: App:Lam:V:null_red[Let][Let]:null_subst[True][Ite]:null_red[Let]:null_subst[Ite]:null_subst:null_red:null_mklam:null_lamvar:null_lambody:null_appe2:null_appe1

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

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

   False => 1
   True => 2
   0 => 0
   null_and => 0
   null_!EQ => 0
   null_red[Let][Let] => 0
   null_subst[True][Ite] => 0
   null_red[Let] => 0
   null_subst[Ite] => 0
   null_subst => 0
   null_red => 0
   null_eqTerm => 0
   null_mklam => 0
   null_lamvar => 0
   null_lambody => 0
   null_isvar => 0
   null_islam => 0
   null_appe2 => 0
   null_appe1 => 0

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

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

   !EQ(z, z') -{ 0 }-> 2 :|: z = 0, z' = 0
   !EQ(z, z') -{ 0 }-> 1 :|: z' = 1 + y, y >= 0, z = 0
   !EQ(z, z') -{ 0 }-> 1 :|: x >= 0, z = 1 + x, z' = 0
   !EQ(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   !EQ(z, z') -{ 0 }-> !EQ(x, y) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   and(z, z') -{ 0 }-> 2 :|: z = 2, z' = 2
   and(z, z') -{ 0 }-> 1 :|: z = 1, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z = 2, z' = 1
   and(z, z') -{ 0 }-> 1 :|: z' = 2, z = 1
   and(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   appe1(z) -{ 1 }-> e1 :|: e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   appe1(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   appe2(z) -{ 1 }-> e2 :|: e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   appe2(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   eqTerm(z, z') -{ 1 }-> and(eqTerm(t11, t21), eqTerm(t12, t22)) :|: z' = 1 + t21 + t22, t11 >= 0, t21 >= 0, t12 >= 0, z = 1 + t11 + t12, t22 >= 0
   eqTerm(z, z') -{ 1 }-> and(!EQ(i1, i2), eqTerm(l1, l2)) :|: i1 >= 0, z' = 1 + i2 + l2, l1 >= 0, i2 >= 0, l2 >= 0, z = 1 + i1 + l1
   eqTerm(z, z') -{ 1 }-> 1 :|: z' = 1 + i2 + l2, t11 >= 0, t12 >= 0, i2 >= 0, l2 >= 0, z = 1 + t11 + t12
   eqTerm(z, z') -{ 1 }-> 1 :|: z' = 1 + v2, t11 >= 0, t12 >= 0, z = 1 + t11 + t12, v2 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: i1 >= 0, z' = 1 + t21 + t22, t21 >= 0, l1 >= 0, z = 1 + i1 + l1, t22 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: i1 >= 0, z' = 1 + v2, l1 >= 0, z = 1 + i1 + l1, v2 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: z = 1 + v1, z' = 1 + t21 + t22, v1 >= 0, t21 >= 0, t22 >= 0
   eqTerm(z, z') -{ 1 }-> 1 :|: z = 1 + v1, z' = 1 + i2 + l2, v1 >= 0, i2 >= 0, l2 >= 0
   eqTerm(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   eqTerm(z, z') -{ 1 }-> !EQ(v1, v2) :|: z' = 1 + v2, z = 1 + v1, v1 >= 0, v2 >= 0
   islam(z) -{ 1 }-> 2 :|: term >= 0, z = 1 + int + term, int >= 0
   islam(z) -{ 1 }-> 1 :|: z = 1 + t1 + t2, t1 >= 0, t2 >= 0
   islam(z) -{ 1 }-> 1 :|: int >= 0, z = 1 + int
   islam(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   isvar(z) -{ 1 }-> 2 :|: int >= 0, z = 1 + int
   isvar(z) -{ 1 }-> 1 :|: z = 1 + t1 + t2, t1 >= 0, t2 >= 0
   isvar(z) -{ 1 }-> 1 :|: term >= 0, z = 1 + int + term, int >= 0
   isvar(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   lambdaint(z) -{ 1 }-> red(e) :|: z = e, e >= 0
   lambody(z) -{ 1 }-> exp :|: var >= 0, z = 1 + var + exp, exp >= 0
   lambody(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   lamvar(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   lamvar(z) -{ 1 }-> 1 + var :|: var >= 0, z = 1 + var + exp, exp >= 0
   mkapp(z, z') -{ 1 }-> 1 + e1 + e2 :|: z' = e2, z = e1, e1 >= 0, e2 >= 0
   mklam(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   mklam(z, z') -{ 1 }-> 1 + name + e :|: z' = e, z = 1 + name, e >= 0, name >= 0
   red(z) -{ 1 }-> red[Let](1 + e1 + e2, red(e1)) :|: e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   red(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   red(z) -{ 1 }-> 1 + int :|: int >= 0, z = 1 + int
   red(z) -{ 1 }-> 1 + int + term :|: term >= 0, z = 1 + int + term, int >= 0
   red[Let](z, z') -{ 0 }-> red[Let][Let](1 + e1 + e2, f, red(e2)) :|: f >= 0, z' = f, e1 >= 0, z = 1 + e1 + e2, e2 >= 0
   red[Let](z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   red[Let][Let](z, z', z'') -{ 0 }-> red(subst(1 + var, a, exp)) :|: z = e, var >= 0, a >= 0, z'' = a, z' = 1 + var + exp, e >= 0, exp >= 0
   red[Let][Let](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   red[Let][Let](z, z', z'') -{ 0 }-> 1 + (1 + int) + e2 :|: z = e, e >= 0, int >= 0, e2 >= 0, z' = 1 + int, z'' = e2
   red[Let][Let](z, z', z'') -{ 0 }-> 1 + (1 + t1 + t2) + e2 :|: z = e, z' = 1 + t1 + t2, t1 >= 0, e >= 0, e2 >= 0, t2 >= 0, z'' = e2
   subst(z, z', z'') -{ 1 }-> subst[True][Ite](eqTerm(x, 1 + var), x, a, 1 + var + exp) :|: z' = a, var >= 0, a >= 0, z'' = 1 + var + exp, x >= 0, z = x, exp >= 0
   subst(z, z', z'') -{ 1 }-> subst[Ite](eqTerm(x, 1 + int), x, a, 1 + int) :|: z' = a, z'' = 1 + int, a >= 0, x >= 0, z = x, int >= 0
   subst(z, z', z'') -{ 1 }-> mkapp(subst(x, a, e1), subst(x, a, e2)) :|: z' = a, z'' = 1 + e1 + e2, a >= 0, x >= 0, e1 >= 0, z = x, e2 >= 0
   subst(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> a :|: z = 2, z' = x, z1 = e, a >= 0, z'' = a, x >= 0, e >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> e :|: z' = x, z1 = e, a >= 0, z = 1, z'' = a, x >= 0, e >= 0
   subst[Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   subst[True][Ite](z, z', z'', z1) -{ 0 }-> e :|: z = 2, z' = x, z1 = e, a >= 0, z'' = a, x >= 0, e >= 0
   subst[True][Ite](z, z', z'', z1) -{ 0 }-> mklam(1 + var, subst(x, a, exp)) :|: z' = x, var >= 0, a >= 0, z = 1, z'' = a, x >= 0, z1 = 1 + var + exp, exp >= 0
   subst[True][Ite](z, z', z'', z1) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0

Only complete derivations are relevant for the runtime complexity.

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

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

(26)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   eqTerm(App(z0, z1), App(z2, z3)) -> and(eqTerm(z0, z2), eqTerm(z1, z3))
   eqTerm(App(z0, z1), Lam(z2, z3)) -> False
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), App(z2, z3)) -> False
   eqTerm(Lam(z0, z1), Lam(z2, z3)) -> and(!EQ(z0, z2), eqTerm(z1, z3))
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), App(z1, z2)) -> False
   eqTerm(V(z0), Lam(z1, z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   mklam(V(z0), z1) -> Lam(z0, z1)
   lamvar(Lam(z0, z1)) -> V(z0)
   lambody(Lam(z0, z1)) -> z1
   isvar(App(z0, z1)) -> False
   isvar(Lam(z0, z1)) -> False
   isvar(V(z0)) -> True
   islam(App(z0, z1)) -> False
   islam(Lam(z0, z1)) -> True
   islam(V(z0)) -> False
   appe2(App(z0, z1)) -> z1
   appe1(App(z0, z1)) -> z0
   mkapp(z0, z1) -> App(z0, z1)
   lambdaint(z0) -> red(z0)
Tuples:
   AND(False, False) -> c
   AND(True, False) -> c1
   AND(False, True) -> c2
   AND(True, True) -> c3
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   !EQ'(0, S(z0)) -> c5
   !EQ'(S(z0), 0) -> c6
   !EQ'(0, 0) -> c7
   RED[LET][LET](z0, Lam(z1, z2), z3) -> c8(RED(subst(V(z1), z3, z2)), SUBST(V(z1), z3, z2))
   RED[LET][LET](z0, App(z1, z2), z3) -> c9
   RED[LET][LET](z0, V(z1), z2) -> c10
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   SUBST[TRUE][ITE](True, z0, z1, z2) -> c12
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   SUBST[ITE](False, z0, z1, z2) -> c14
   SUBST[ITE](True, z0, z1, z2) -> c15
   SUBST(z0, z1, App(z2, z3)) -> c16(MKAPP(subst(z0, z1, z2), subst(z0, z1, z3)), SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(MKAPP(subst(z0, z1, z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   SUBST(z0, z1, V(z2)) -> c19(SUBST[ITE](eqTerm(z0, V(z2)), z0, z1, V(z2)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(AND(eqTerm(z0, z2), eqTerm(z1, z3)), EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(AND(eqTerm(z0, z2), eqTerm(z1, z3)), EQTERM(z1, z3))
   EQTERM(App(z0, z1), Lam(z2, z3)) -> c25
   EQTERM(App(z0, z1), V(z2)) -> c26
   EQTERM(Lam(z0, z1), App(z2, z3)) -> c27
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(AND(!EQ(z0, z2), eqTerm(z1, z3)), !EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(AND(!EQ(z0, z2), eqTerm(z1, z3)), EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), V(z2)) -> c30
   EQTERM(V(z0), App(z1, z2)) -> c31
   EQTERM(V(z0), Lam(z1, z2)) -> c32
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   LAMVAR(Lam(z0, z1)) -> c35
   LAMBODY(Lam(z0, z1)) -> c36
   ISVAR(App(z0, z1)) -> c37
   ISVAR(Lam(z0, z1)) -> c38
   ISVAR(V(z0)) -> c39
   ISLAM(App(z0, z1)) -> c40
   ISLAM(Lam(z0, z1)) -> c41
   ISLAM(V(z0)) -> c42
   APPE2(App(z0, z1)) -> c43
   APPE1(App(z0, z1)) -> c44
   MKAPP(z0, z1) -> c45
   LAMBDAINT(z0) -> c46(RED(z0))
S tuples:
   SUBST(z0, z1, App(z2, z3)) -> c16(MKAPP(subst(z0, z1, z2), subst(z0, z1, z3)), SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(MKAPP(subst(z0, z1, z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   SUBST(z0, z1, V(z2)) -> c19(SUBST[ITE](eqTerm(z0, V(z2)), z0, z1, V(z2)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(AND(eqTerm(z0, z2), eqTerm(z1, z3)), EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(AND(eqTerm(z0, z2), eqTerm(z1, z3)), EQTERM(z1, z3))
   EQTERM(App(z0, z1), Lam(z2, z3)) -> c25
   EQTERM(App(z0, z1), V(z2)) -> c26
   EQTERM(Lam(z0, z1), App(z2, z3)) -> c27
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(AND(!EQ(z0, z2), eqTerm(z1, z3)), !EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(AND(!EQ(z0, z2), eqTerm(z1, z3)), EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), V(z2)) -> c30
   EQTERM(V(z0), App(z1, z2)) -> c31
   EQTERM(V(z0), Lam(z1, z2)) -> c32
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   LAMVAR(Lam(z0, z1)) -> c35
   LAMBODY(Lam(z0, z1)) -> c36
   ISVAR(App(z0, z1)) -> c37
   ISVAR(Lam(z0, z1)) -> c38
   ISVAR(V(z0)) -> c39
   ISLAM(App(z0, z1)) -> c40
   ISLAM(Lam(z0, z1)) -> c41
   ISLAM(V(z0)) -> c42
   APPE2(App(z0, z1)) -> c43
   APPE1(App(z0, z1)) -> c44
   MKAPP(z0, z1) -> c45
   LAMBDAINT(z0) -> c46(RED(z0))
K tuples:none
Defined Rule Symbols:   subst_3, red_1, eqTerm_2, mklam_2, lamvar_1, lambody_1, isvar_1, islam_1, appe2_1, appe1_1, mkapp_2, lambdaint_1, and_2, !EQ_2, red[Let][Let]_3, subst[True][Ite]_4, red[Let]_2, subst[Ite]_4

Defined Pair Symbols:   AND_2, !EQ'_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, RED[LET]_2, SUBST[ITE]_4, SUBST_3, RED_1, EQTERM_2, MKLAM_2, LAMVAR_1, LAMBODY_1, ISVAR_1, ISLAM_1, APPE2_1, APPE1_1, MKAPP_2, LAMBDAINT_1

Compound Symbols:   c, c1, c2, c3, c4_1, c5, c6, c7, c8_2, c9, c10, c11_2, c12, c13_2, c14, c15, c16_2, c17_2, c18_2, c19_2, c20_2, c21, c22, c23_2, c24_2, c25, c26, c27, c28_2, c29_2, c30, c31, c32, c33_1, c34, c35, c36, c37, c38, c39, c40, c41, c42, c43, c44, c45, c46_1


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

(27) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   LAMBDAINT(z0) -> c46(RED(z0))
Removed 29 trailing nodes:
   MKAPP(z0, z1) -> c45
   EQTERM(Lam(z0, z1), App(z2, z3)) -> c27
   SUBST[ITE](True, z0, z1, z2) -> c15
   LAMBODY(Lam(z0, z1)) -> c36
   RED[LET][LET](z0, V(z1), z2) -> c10
   APPE1(App(z0, z1)) -> c44
   !EQ'(0, 0) -> c7
   !EQ'(0, S(z0)) -> c5
   ISVAR(Lam(z0, z1)) -> c38
   ISLAM(Lam(z0, z1)) -> c41
   ISLAM(App(z0, z1)) -> c40
   ISVAR(App(z0, z1)) -> c37
   !EQ'(S(z0), 0) -> c6
   ISLAM(V(z0)) -> c42
   AND(True, False) -> c1
   LAMVAR(Lam(z0, z1)) -> c35
   EQTERM(App(z0, z1), Lam(z2, z3)) -> c25
   EQTERM(V(z0), App(z1, z2)) -> c31
   EQTERM(Lam(z0, z1), V(z2)) -> c30
   AND(False, True) -> c2
   EQTERM(V(z0), Lam(z1, z2)) -> c32
   SUBST[ITE](False, z0, z1, z2) -> c14
   AND(False, False) -> c
   RED[LET][LET](z0, App(z1, z2), z3) -> c9
   APPE2(App(z0, z1)) -> c43
   SUBST[TRUE][ITE](True, z0, z1, z2) -> c12
   EQTERM(App(z0, z1), V(z2)) -> c26
   ISVAR(V(z0)) -> c39
   AND(True, True) -> c3

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

(28)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   eqTerm(App(z0, z1), App(z2, z3)) -> and(eqTerm(z0, z2), eqTerm(z1, z3))
   eqTerm(App(z0, z1), Lam(z2, z3)) -> False
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), App(z2, z3)) -> False
   eqTerm(Lam(z0, z1), Lam(z2, z3)) -> and(!EQ(z0, z2), eqTerm(z1, z3))
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), App(z1, z2)) -> False
   eqTerm(V(z0), Lam(z1, z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   mklam(V(z0), z1) -> Lam(z0, z1)
   lamvar(Lam(z0, z1)) -> V(z0)
   lambody(Lam(z0, z1)) -> z1
   isvar(App(z0, z1)) -> False
   isvar(Lam(z0, z1)) -> False
   isvar(V(z0)) -> True
   islam(App(z0, z1)) -> False
   islam(Lam(z0, z1)) -> True
   islam(V(z0)) -> False
   appe2(App(z0, z1)) -> z1
   appe1(App(z0, z1)) -> z0
   mkapp(z0, z1) -> App(z0, z1)
   lambdaint(z0) -> red(z0)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   RED[LET][LET](z0, Lam(z1, z2), z3) -> c8(RED(subst(V(z1), z3, z2)), SUBST(V(z1), z3, z2))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   SUBST(z0, z1, App(z2, z3)) -> c16(MKAPP(subst(z0, z1, z2), subst(z0, z1, z3)), SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(MKAPP(subst(z0, z1, z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   SUBST(z0, z1, V(z2)) -> c19(SUBST[ITE](eqTerm(z0, V(z2)), z0, z1, V(z2)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(AND(eqTerm(z0, z2), eqTerm(z1, z3)), EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(AND(eqTerm(z0, z2), eqTerm(z1, z3)), EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(AND(!EQ(z0, z2), eqTerm(z1, z3)), !EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(AND(!EQ(z0, z2), eqTerm(z1, z3)), EQTERM(z1, z3))
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
S tuples:
   SUBST(z0, z1, App(z2, z3)) -> c16(MKAPP(subst(z0, z1, z2), subst(z0, z1, z3)), SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(MKAPP(subst(z0, z1, z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   SUBST(z0, z1, V(z2)) -> c19(SUBST[ITE](eqTerm(z0, V(z2)), z0, z1, V(z2)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(AND(eqTerm(z0, z2), eqTerm(z1, z3)), EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(AND(eqTerm(z0, z2), eqTerm(z1, z3)), EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(AND(!EQ(z0, z2), eqTerm(z1, z3)), !EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(AND(!EQ(z0, z2), eqTerm(z1, z3)), EQTERM(z1, z3))
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
K tuples:none
Defined Rule Symbols:   subst_3, red_1, eqTerm_2, mklam_2, lamvar_1, lambody_1, isvar_1, islam_1, appe2_1, appe1_1, mkapp_2, lambdaint_1, and_2, !EQ_2, red[Let][Let]_3, subst[True][Ite]_4, red[Let]_2, subst[Ite]_4

Defined Pair Symbols:   !EQ'_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, RED[LET]_2, SUBST_3, RED_1, EQTERM_2, MKLAM_2

Compound Symbols:   c4_1, c8_2, c11_2, c13_2, c16_2, c17_2, c18_2, c19_2, c20_2, c21, c22, c23_2, c24_2, c28_2, c29_2, c33_1, c34


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

(29) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 7 trailing tuple parts
----------------------------------------

(30)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   eqTerm(App(z0, z1), App(z2, z3)) -> and(eqTerm(z0, z2), eqTerm(z1, z3))
   eqTerm(App(z0, z1), Lam(z2, z3)) -> False
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), App(z2, z3)) -> False
   eqTerm(Lam(z0, z1), Lam(z2, z3)) -> and(!EQ(z0, z2), eqTerm(z1, z3))
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), App(z1, z2)) -> False
   eqTerm(V(z0), Lam(z1, z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   mklam(V(z0), z1) -> Lam(z0, z1)
   lamvar(Lam(z0, z1)) -> V(z0)
   lambody(Lam(z0, z1)) -> z1
   isvar(App(z0, z1)) -> False
   isvar(Lam(z0, z1)) -> False
   isvar(V(z0)) -> True
   islam(App(z0, z1)) -> False
   islam(Lam(z0, z1)) -> True
   islam(V(z0)) -> False
   appe2(App(z0, z1)) -> z1
   appe1(App(z0, z1)) -> z0
   mkapp(z0, z1) -> App(z0, z1)
   lambdaint(z0) -> red(z0)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   RED[LET][LET](z0, Lam(z1, z2), z3) -> c8(RED(subst(V(z1), z3, z2)), SUBST(V(z1), z3, z2))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
S tuples:
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
K tuples:none
Defined Rule Symbols:   subst_3, red_1, eqTerm_2, mklam_2, lamvar_1, lambody_1, isvar_1, islam_1, appe2_1, appe1_1, mkapp_2, lambdaint_1, and_2, !EQ_2, red[Let][Let]_3, subst[True][Ite]_4, red[Let]_2, subst[Ite]_4

Defined Pair Symbols:   !EQ'_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, RED[LET]_2, SUBST_3, RED_1, EQTERM_2, MKLAM_2

Compound Symbols:   c4_1, c8_2, c11_2, c13_2, c18_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1


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

(31) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   and(False, False) -> False
   and(True, False) -> False
   and(False, True) -> False
   and(True, True) -> True
   eqTerm(App(z0, z1), App(z2, z3)) -> and(eqTerm(z0, z2), eqTerm(z1, z3))
   eqTerm(App(z0, z1), Lam(z2, z3)) -> False
   eqTerm(Lam(z0, z1), App(z2, z3)) -> False
   eqTerm(Lam(z0, z1), Lam(z2, z3)) -> and(!EQ(z0, z2), eqTerm(z1, z3))
   eqTerm(V(z0), App(z1, z2)) -> False
   eqTerm(V(z0), Lam(z1, z2)) -> False
   lamvar(Lam(z0, z1)) -> V(z0)
   lambody(Lam(z0, z1)) -> z1
   isvar(App(z0, z1)) -> False
   isvar(Lam(z0, z1)) -> False
   isvar(V(z0)) -> True
   islam(App(z0, z1)) -> False
   islam(Lam(z0, z1)) -> True
   islam(V(z0)) -> False
   appe2(App(z0, z1)) -> z1
   appe1(App(z0, z1)) -> z0
   lambdaint(z0) -> red(z0)

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

(32)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   RED[LET][LET](z0, Lam(z1, z2), z3) -> c8(RED(subst(V(z1), z3, z2)), SUBST(V(z1), z3, z2))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
S tuples:
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
K tuples:none
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, RED[LET]_2, SUBST_3, RED_1, EQTERM_2, MKLAM_2

Compound Symbols:   c4_1, c8_2, c11_2, c13_2, c18_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1


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

(33) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
We considered the (Usable) Rules:none
And the Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   RED[LET][LET](z0, Lam(z1, z2), z3) -> c8(RED(subst(V(z1), z3, z2)), SUBST(V(z1), z3, z2))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(!EQ(x_1, x_2)) = [1] + x_1 + x_2
   POL(!EQ'(x_1, x_2)) = 0
   POL(0) = [1]
   POL(App(x_1, x_2)) = x_1 + x_2
   POL(EQTERM(x_1, x_2)) = x_2
   POL(False) = [1]
   POL(Lam(x_1, x_2)) = [1] + x_2
   POL(MKLAM(x_1, x_2)) = x_1
   POL(RED(x_1)) = 0
   POL(RED[LET](x_1, x_2)) = 0
   POL(RED[LET][LET](x_1, x_2, x_3)) = 0
   POL(S(x_1)) = [1] + x_1
   POL(SUBST(x_1, x_2, x_3)) = x_1
   POL(SUBST[TRUE][ITE](x_1, x_2, x_3, x_4)) = x_2
   POL(True) = [1]
   POL(V(x_1)) = 0
   POL(c11(x_1, x_2)) = x_1 + x_2
   POL(c13(x_1, x_2)) = x_1 + x_2
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c18(x_1, x_2)) = x_1 + x_2
   POL(c19(x_1)) = x_1
   POL(c20(x_1, x_2)) = x_1 + x_2
   POL(c21) = 0
   POL(c22) = 0
   POL(c23(x_1)) = x_1
   POL(c24(x_1)) = x_1
   POL(c28(x_1)) = x_1
   POL(c29(x_1)) = x_1
   POL(c33(x_1)) = x_1
   POL(c34) = 0
   POL(c4(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(eqTerm(x_1, x_2)) = [1] + x_1 + x_2
   POL(mkapp(x_1, x_2)) = [1] + x_1 + x_2
   POL(mklam(x_1, x_2)) = [1] + x_1 + x_2
   POL(red(x_1)) = [1]
   POL(red[Let](x_1, x_2)) = [1] + x_1 + x_2
   POL(red[Let][Let](x_1, x_2, x_3)) = [1] + x_1 + x_2
   POL(subst(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3
   POL(subst[Ite](x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4
   POL(subst[True][Ite](x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4

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

(34)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   RED[LET][LET](z0, Lam(z1, z2), z3) -> c8(RED(subst(V(z1), z3, z2)), SUBST(V(z1), z3, z2))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
S tuples:
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, RED[LET]_2, SUBST_3, RED_1, EQTERM_2, MKLAM_2

Compound Symbols:   c4_1, c8_2, c11_2, c13_2, c18_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1


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

(35) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
We considered the (Usable) Rules:none
And the Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   RED[LET][LET](z0, Lam(z1, z2), z3) -> c8(RED(subst(V(z1), z3, z2)), SUBST(V(z1), z3, z2))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(!EQ(x_1, x_2)) = [1] + x_1 + x_2
   POL(!EQ'(x_1, x_2)) = 0
   POL(0) = [1]
   POL(App(x_1, x_2)) = [1] + x_1 + x_2
   POL(EQTERM(x_1, x_2)) = x_2
   POL(False) = [1]
   POL(Lam(x_1, x_2)) = x_2
   POL(MKLAM(x_1, x_2)) = x_1
   POL(RED(x_1)) = 0
   POL(RED[LET](x_1, x_2)) = 0
   POL(RED[LET][LET](x_1, x_2, x_3)) = 0
   POL(S(x_1)) = [1] + x_1
   POL(SUBST(x_1, x_2, x_3)) = x_1
   POL(SUBST[TRUE][ITE](x_1, x_2, x_3, x_4)) = x_2
   POL(True) = [1]
   POL(V(x_1)) = 0
   POL(c11(x_1, x_2)) = x_1 + x_2
   POL(c13(x_1, x_2)) = x_1 + x_2
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c18(x_1, x_2)) = x_1 + x_2
   POL(c19(x_1)) = x_1
   POL(c20(x_1, x_2)) = x_1 + x_2
   POL(c21) = 0
   POL(c22) = 0
   POL(c23(x_1)) = x_1
   POL(c24(x_1)) = x_1
   POL(c28(x_1)) = x_1
   POL(c29(x_1)) = x_1
   POL(c33(x_1)) = x_1
   POL(c34) = 0
   POL(c4(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(eqTerm(x_1, x_2)) = [1] + x_1 + x_2
   POL(mkapp(x_1, x_2)) = [1] + x_1 + x_2
   POL(mklam(x_1, x_2)) = [1] + x_1 + x_2
   POL(red(x_1)) = [1]
   POL(red[Let](x_1, x_2)) = [1] + x_1 + x_2
   POL(red[Let][Let](x_1, x_2, x_3)) = [1] + x_1 + x_2
   POL(subst(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3
   POL(subst[Ite](x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4
   POL(subst[True][Ite](x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4

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

(36)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   RED[LET][LET](z0, Lam(z1, z2), z3) -> c8(RED(subst(V(z1), z3, z2)), SUBST(V(z1), z3, z2))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
S tuples:
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, RED[LET]_2, SUBST_3, RED_1, EQTERM_2, MKLAM_2

Compound Symbols:   c4_1, c8_2, c11_2, c13_2, c18_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1


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

(37) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace RED[LET][LET](z0, Lam(z1, z2), z3) -> c8(RED(subst(V(z1), z3, z2)), SUBST(V(z1), z3, z2)) by 
   RED[LET][LET](x0, Lam(x1, App(z2, z3)), z1) -> c8(RED(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3))), SUBST(V(x1), z1, App(z2, z3)))
   RED[LET][LET](x0, Lam(x1, Lam(z2, z3)), z1) -> c8(RED(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3))), SUBST(V(x1), z1, Lam(z2, z3)))
   RED[LET][LET](x0, Lam(x1, V(z2)), z1) -> c8(RED(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2))), SUBST(V(x1), z1, V(z2)))

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

(38)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   RED[LET][LET](x0, Lam(x1, App(z2, z3)), z1) -> c8(RED(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3))), SUBST(V(x1), z1, App(z2, z3)))
   RED[LET][LET](x0, Lam(x1, Lam(z2, z3)), z1) -> c8(RED(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3))), SUBST(V(x1), z1, Lam(z2, z3)))
   RED[LET][LET](x0, Lam(x1, V(z2)), z1) -> c8(RED(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2))), SUBST(V(x1), z1, V(z2)))
S tuples:
   SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2)))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, SUBST[TRUE][ITE]_4, RED[LET]_2, SUBST_3, RED_1, EQTERM_2, MKLAM_2, RED[LET][LET]_3

Compound Symbols:   c4_1, c11_2, c13_2, c18_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c8_2


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

(39) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace SUBST(z0, z1, Lam(z2, z3)) -> c18(SUBST[TRUE][ITE](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3)), EQTERM(z0, V(z2))) by 
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)), EQTERM(App(z0, z1), V(z2)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)), EQTERM(Lam(z0, z1), V(z2)))
   SUBST(V(z0), x1, Lam(z1, x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(z0), x1, Lam(z1, x3)), EQTERM(V(z0), V(z1)))

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

(40)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   RED[LET][LET](x0, Lam(x1, App(z2, z3)), z1) -> c8(RED(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3))), SUBST(V(x1), z1, App(z2, z3)))
   RED[LET][LET](x0, Lam(x1, Lam(z2, z3)), z1) -> c8(RED(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3))), SUBST(V(x1), z1, Lam(z2, z3)))
   RED[LET][LET](x0, Lam(x1, V(z2)), z1) -> c8(RED(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2))), SUBST(V(x1), z1, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)), EQTERM(App(z0, z1), V(z2)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)), EQTERM(Lam(z0, z1), V(z2)))
   SUBST(V(z0), x1, Lam(z1, x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(z0), x1, Lam(z1, x3)), EQTERM(V(z0), V(z1)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)), EQTERM(App(z0, z1), V(z2)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)), EQTERM(Lam(z0, z1), V(z2)))
   SUBST(V(z0), x1, Lam(z1, x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(z0), x1, Lam(z1, x3)), EQTERM(V(z0), V(z1)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, SUBST[TRUE][ITE]_4, RED[LET]_2, RED_1, EQTERM_2, MKLAM_2, SUBST_3, RED[LET][LET]_3

Compound Symbols:   c4_1, c11_2, c13_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c8_2, c18_2


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

(41) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(42)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   RED[LET][LET](x0, Lam(x1, App(z2, z3)), z1) -> c8(RED(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3))), SUBST(V(x1), z1, App(z2, z3)))
   RED[LET][LET](x0, Lam(x1, Lam(z2, z3)), z1) -> c8(RED(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3))), SUBST(V(x1), z1, Lam(z2, z3)))
   RED[LET][LET](x0, Lam(x1, V(z2)), z1) -> c8(RED(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2))), SUBST(V(x1), z1, V(z2)))
   SUBST(V(z0), x1, Lam(z1, x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(z0), x1, Lam(z1, x3)), EQTERM(V(z0), V(z1)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(V(z0), x1, Lam(z1, x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(z0), x1, Lam(z1, x3)), EQTERM(V(z0), V(z1)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, SUBST[TRUE][ITE]_4, RED[LET]_2, RED_1, EQTERM_2, MKLAM_2, SUBST_3, RED[LET][LET]_3

Compound Symbols:   c4_1, c11_2, c13_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c8_2, c18_2, c18_1


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

(43) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace RED[LET][LET](x0, Lam(x1, App(z2, z3)), z1) -> c8(RED(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3))), SUBST(V(x1), z1, App(z2, z3))) by 
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(RED(App(subst(V(x1), x4, x2), subst(V(x1), x4, x3))), SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, App(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)))), SUBST(V(x1), z1, App(x2, App(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))

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

(44)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   RED[LET][LET](x0, Lam(x1, Lam(z2, z3)), z1) -> c8(RED(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3))), SUBST(V(x1), z1, Lam(z2, z3)))
   RED[LET][LET](x0, Lam(x1, V(z2)), z1) -> c8(RED(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2))), SUBST(V(x1), z1, V(z2)))
   SUBST(V(z0), x1, Lam(z1, x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(z0), x1, Lam(z1, x3)), EQTERM(V(z0), V(z1)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(RED(App(subst(V(x1), x4, x2), subst(V(x1), x4, x3))), SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, App(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)))), SUBST(V(x1), z1, App(x2, App(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(V(z0), x1, Lam(z1, x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(z0), x1, Lam(z1, x3)), EQTERM(V(z0), V(z1)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, SUBST[TRUE][ITE]_4, RED[LET]_2, RED_1, EQTERM_2, MKLAM_2, SUBST_3, RED[LET][LET]_3

Compound Symbols:   c4_1, c11_2, c13_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c8_2, c18_2, c18_1, c8_1


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

(45) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace RED[LET][LET](x0, Lam(x1, Lam(z2, z3)), z1) -> c8(RED(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3))), SUBST(V(x1), z1, Lam(z2, z3))) by 
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))

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

(46)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   RED[LET][LET](x0, Lam(x1, V(z2)), z1) -> c8(RED(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2))), SUBST(V(x1), z1, V(z2)))
   SUBST(V(z0), x1, Lam(z1, x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(z0), x1, Lam(z1, x3)), EQTERM(V(z0), V(z1)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(RED(App(subst(V(x1), x4, x2), subst(V(x1), x4, x3))), SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, App(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)))), SUBST(V(x1), z1, App(x2, App(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(V(z0), x1, Lam(z1, x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(z0), x1, Lam(z1, x3)), EQTERM(V(z0), V(z1)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, SUBST[TRUE][ITE]_4, RED[LET]_2, RED_1, EQTERM_2, MKLAM_2, SUBST_3, RED[LET][LET]_3

Compound Symbols:   c4_1, c11_2, c13_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c8_2, c18_2, c18_1, c8_1


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

(47) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace RED[LET][LET](x0, Lam(x1, V(z2)), z1) -> c8(RED(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2))), SUBST(V(x1), z1, V(z2))) by 
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))

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

(48)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(V(z0), x1, Lam(z1, x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(z0), x1, Lam(z1, x3)), EQTERM(V(z0), V(z1)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(RED(App(subst(V(x1), x4, x2), subst(V(x1), x4, x3))), SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, App(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)))), SUBST(V(x1), z1, App(x2, App(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(V(z0), x1, Lam(z1, x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(z0), x1, Lam(z1, x3)), EQTERM(V(z0), V(z1)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, SUBST[TRUE][ITE]_4, RED[LET]_2, RED_1, EQTERM_2, MKLAM_2, SUBST_3, RED[LET][LET]_3

Compound Symbols:   c4_1, c11_2, c13_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_2, c18_1, c8_2, c8_1


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

(49) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace SUBST(V(z0), x1, Lam(z1, x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(z0), x1, Lam(z1, x3)), EQTERM(V(z0), V(z1))) by 
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](True, V(0), x1, Lam(0, x3)), EQTERM(V(0), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))

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

(50)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(RED(App(subst(V(x1), x4, x2), subst(V(x1), x4, x3))), SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, App(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)))), SUBST(V(x1), z1, App(x2, App(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](True, V(0), x1, Lam(0, x3)), EQTERM(V(0), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](True, V(0), x1, Lam(0, x3)), EQTERM(V(0), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, SUBST[TRUE][ITE]_4, RED[LET]_2, RED_1, EQTERM_2, MKLAM_2, SUBST_3, RED[LET][LET]_3

Compound Symbols:   c4_1, c11_2, c13_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2


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

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

(52)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(RED(App(subst(V(x1), x4, x2), subst(V(x1), x4, x3))), SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, App(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)))), SUBST(V(x1), z1, App(x2, App(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(EQTERM(V(0), V(0)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(EQTERM(V(0), V(0)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, SUBST[TRUE][ITE]_4, RED[LET]_2, RED_1, EQTERM_2, MKLAM_2, SUBST_3, RED[LET][LET]_3

Compound Symbols:   c4_1, c11_2, c13_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2


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

(53) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace SUBST[TRUE][ITE](False, z0, z1, Lam(z2, z3)) -> c11(MKLAM(V(z2), subst(z0, z1, z3)), SUBST(z0, z1, z3)) by 
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))

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

(54)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(RED(App(subst(V(x1), x4, x2), subst(V(x1), x4, x3))), SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, App(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)))), SUBST(V(x1), z1, App(x2, App(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(EQTERM(V(0), V(0)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(EQTERM(V(0), V(0)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, RED[LET]_2, RED_1, EQTERM_2, MKLAM_2, SUBST_3, RED[LET][LET]_3, SUBST[TRUE][ITE]_4

Compound Symbols:   c4_1, c13_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2, c11_2


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

(55) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(RED(App(subst(V(x1), x4, x2), subst(V(x1), x4, x3))), SUBST(V(x1), x4, App(x2, x3))) by 
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))

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

(56)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1))
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, App(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)))), SUBST(V(x1), z1, App(x2, App(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(EQTERM(V(0), V(0)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(EQTERM(V(0), V(0)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   !EQ'_2, RED[LET]_2, RED_1, EQTERM_2, MKLAM_2, SUBST_3, RED[LET][LET]_3, SUBST[TRUE][ITE]_4

Compound Symbols:   c4_1, c13_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2, c11_2


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

(57) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace !EQ'(S(z0), S(z1)) -> c4(!EQ'(z0, z1)) by 
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))

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

(58)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, App(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)))), SUBST(V(x1), z1, App(x2, App(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(EQTERM(V(0), V(0)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1))
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(EQTERM(V(0), V(0)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, EQTERM_2, MKLAM_2, SUBST_3, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c33_1, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2, c11_2, c4_1


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

(59) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace EQTERM(V(z0), V(z1)) -> c33(!EQ'(z0, z1)) by 
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))

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

(60)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, App(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)))), SUBST(V(x1), z1, App(x2, App(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(EQTERM(V(0), V(0)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)), EQTERM(V(0), V(S(z0))))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)), EQTERM(V(S(z0)), V(0)))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18(EQTERM(V(0), V(0)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2, c11_2, c4_1, c33_1


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

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

(62)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, App(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)))), SUBST(V(x1), z1, App(x2, App(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2, c11_2, c4_1, c33_1, c18


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

(63) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace RED[LET][LET](x0, Lam(x1, App(x2, App(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)))), SUBST(V(x1), z1, App(x2, App(z2, z3)))) by RED[LET][LET](z0, Lam(z1, App(z2, App(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), mkapp(subst(V(z1), z5, z3), subst(V(z1), z5, z4)))), SUBST(V(z1), z5, App(z2, App(z3, z4))))
----------------------------------------

(64)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3))))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](z0, Lam(z1, App(z2, App(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), mkapp(subst(V(z1), z5, z3), subst(V(z1), z5, z4)))), SUBST(V(z1), z5, App(z2, App(z3, z4))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2, c11_2, c4_1, c33_1, c18


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

(65) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace RED[LET][LET](x0, Lam(x1, App(x2, Lam(z2, z3))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)))), SUBST(V(x1), z1, App(x2, Lam(z2, z3)))) by RED[LET][LET](z0, Lam(z1, App(z2, Lam(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), z5, Lam(z3, z4)))), SUBST(V(z1), z5, App(z2, Lam(z3, z4))))
----------------------------------------

(66)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2))))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](z0, Lam(z1, App(z2, App(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), mkapp(subst(V(z1), z5, z3), subst(V(z1), z5, z4)))), SUBST(V(z1), z5, App(z2, App(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, Lam(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), z5, Lam(z3, z4)))), SUBST(V(z1), z5, App(z2, Lam(z3, z4))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2, c11_2, c4_1, c33_1, c18


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

(67) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace RED[LET][LET](x0, Lam(x1, App(x2, V(z2))), z1) -> c8(RED(mkapp(subst(V(x1), z1, x2), subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)))), SUBST(V(x1), z1, App(x2, V(z2)))) by RED[LET][LET](z0, Lam(z1, App(z2, V(z3))), z4) -> c8(RED(App(subst(V(z1), z4, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), z4, V(z3)))), SUBST(V(z1), z4, App(z2, V(z3))))
----------------------------------------

(68)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](z0, Lam(z1, App(z2, App(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), mkapp(subst(V(z1), z5, z3), subst(V(z1), z5, z4)))), SUBST(V(z1), z5, App(z2, App(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, Lam(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), z5, Lam(z3, z4)))), SUBST(V(z1), z5, App(z2, Lam(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, V(z3))), z4) -> c8(RED(App(subst(V(z1), z4, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), z4, V(z3)))), SUBST(V(z1), z4, App(z2, V(z3))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2, c11_2, c4_1, c33_1, c18


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

(69) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace RED[LET][LET](x0, Lam(x1, App(App(z2, z3), x3)), z1) -> c8(RED(mkapp(mkapp(subst(V(x1), z1, z2), subst(V(x1), z1, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(App(z2, z3), x3))) by 
   RED[LET][LET](App(x0, x1), Lam(z1, App(App(z2, z3), z4)), y0) -> c8(RED(mkapp(mkapp(subst(V(z1), y0, z2), subst(V(z1), y0, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(App(z2, z3), z4)))

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

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](z0, Lam(z1, App(z2, App(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), mkapp(subst(V(z1), z5, z3), subst(V(z1), z5, z4)))), SUBST(V(z1), z5, App(z2, App(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, Lam(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), z5, Lam(z3, z4)))), SUBST(V(z1), z5, App(z2, Lam(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, V(z3))), z4) -> c8(RED(App(subst(V(z1), z4, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), z4, V(z3)))), SUBST(V(z1), z4, App(z2, V(z3))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(App(z2, z3), z4)), y0) -> c8(RED(mkapp(mkapp(subst(V(z1), y0, z2), subst(V(z1), y0, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(App(z2, z3), z4)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2, c11_2, c4_1, c33_1, c18


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

(71) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace RED[LET][LET](x0, Lam(x1, App(Lam(z2, z3), x3)), z1) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(x1), V(z2)), V(x1), z1, Lam(z2, z3)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(Lam(z2, z3), x3))) by 
   RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4)))

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

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](z0, Lam(z1, App(z2, App(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), mkapp(subst(V(z1), z5, z3), subst(V(z1), z5, z4)))), SUBST(V(z1), z5, App(z2, App(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, Lam(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), z5, Lam(z3, z4)))), SUBST(V(z1), z5, App(z2, Lam(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, V(z3))), z4) -> c8(RED(App(subst(V(z1), z4, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), z4, V(z3)))), SUBST(V(z1), z4, App(z2, V(z3))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(App(z2, z3), z4)), y0) -> c8(RED(mkapp(mkapp(subst(V(z1), y0, z2), subst(V(z1), y0, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(App(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2, c11_2, c4_1, c33_1, c18


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

(73) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace RED[LET][LET](x0, Lam(x1, App(V(z2), x3)), z1) -> c8(RED(mkapp(subst[Ite](eqTerm(V(x1), V(z2)), V(x1), z1, V(z2)), subst(V(x1), z1, x3))), SUBST(V(x1), z1, App(V(z2), x3))) by 
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))

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

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](z0, Lam(z1, App(z2, App(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), mkapp(subst(V(z1), z5, z3), subst(V(z1), z5, z4)))), SUBST(V(z1), z5, App(z2, App(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, Lam(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), z5, Lam(z3, z4)))), SUBST(V(z1), z5, App(z2, Lam(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, V(z3))), z4) -> c8(RED(App(subst(V(z1), z4, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), z4, V(z3)))), SUBST(V(z1), z4, App(z2, V(z3))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(App(z2, z3), z4)), y0) -> c8(RED(mkapp(mkapp(subst(V(z1), y0, z2), subst(V(z1), y0, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(App(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_1, c8_2, c18_2, c11_2, c4_1, c33_1, c18


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

(75) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace RED[LET][LET](x0, Lam(x1, App(x2, x3)), x4) -> c8(SUBST(V(x1), x4, App(x2, x3))) by 
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))

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

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](z0, Lam(z1, App(z2, App(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), mkapp(subst(V(z1), z5, z3), subst(V(z1), z5, z4)))), SUBST(V(z1), z5, App(z2, App(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, Lam(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), z5, Lam(z3, z4)))), SUBST(V(z1), z5, App(z2, Lam(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, V(z3))), z4) -> c8(RED(App(subst(V(z1), z4, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), z4, V(z3)))), SUBST(V(z1), z4, App(z2, V(z3))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(App(z2, z3), z4)), y0) -> c8(RED(mkapp(mkapp(subst(V(z1), y0, z2), subst(V(z1), y0, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(App(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2, c11_2, c4_1, c33_1, c18


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

(77) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace RED[LET][LET](x0, Lam(z0, Lam(z1, x3)), x4) -> c8(RED(subst[True][Ite](!EQ(z0, z1), V(z0), x4, Lam(z1, x3))), SUBST(V(z0), x4, Lam(z1, x3))) by 
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))

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

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](z0, Lam(z1, App(z2, App(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), mkapp(subst(V(z1), z5, z3), subst(V(z1), z5, z4)))), SUBST(V(z1), z5, App(z2, App(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, Lam(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), z5, Lam(z3, z4)))), SUBST(V(z1), z5, App(z2, Lam(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, V(z3))), z4) -> c8(RED(App(subst(V(z1), z4, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), z4, V(z3)))), SUBST(V(z1), z4, App(z2, V(z3))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(App(z2, z3), z4)), y0) -> c8(RED(mkapp(mkapp(subst(V(z1), y0, z2), subst(V(z1), y0, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(App(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_2, c8_1, c18_2, c11_2, c4_1, c33_1, c18


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

(79) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace RED[LET][LET](x0, Lam(z0, V(z1)), x3) -> c8(RED(subst[Ite](!EQ(z0, z1), V(z0), x3, V(z1))), SUBST(V(z0), x3, V(z1))) by 
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))

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

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](z0, Lam(z1, App(z2, App(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), mkapp(subst(V(z1), z5, z3), subst(V(z1), z5, z4)))), SUBST(V(z1), z5, App(z2, App(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, Lam(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), z5, Lam(z3, z4)))), SUBST(V(z1), z5, App(z2, Lam(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, V(z3))), z4) -> c8(RED(App(subst(V(z1), z4, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), z4, V(z3)))), SUBST(V(z1), z4, App(z2, V(z3))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(App(z2, z3), z4)), y0) -> c8(RED(mkapp(mkapp(subst(V(z1), y0, z2), subst(V(z1), y0, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(App(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, RED[LET][LET]_3, SUBST[TRUE][ITE]_4, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c8_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18


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

(81) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace RED[LET][LET](x0, Lam(x1, V(x2)), x3) -> c8(SUBST(V(x1), x3, V(x2))) by 
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))

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

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](z0, Lam(z1, App(z2, App(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), mkapp(subst(V(z1), z5, z3), subst(V(z1), z5, z4)))), SUBST(V(z1), z5, App(z2, App(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, Lam(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), z5, Lam(z3, z4)))), SUBST(V(z1), z5, App(z2, Lam(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, V(z3))), z4) -> c8(RED(App(subst(V(z1), z4, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), z4, V(z3)))), SUBST(V(z1), z4, App(z2, V(z3))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(App(z2, z3), z4)), y0) -> c8(RED(mkapp(mkapp(subst(V(z1), y0, z2), subst(V(z1), y0, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(App(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1


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

(83) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace RED[LET][LET](z0, Lam(z1, App(z2, App(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), mkapp(subst(V(z1), z5, z3), subst(V(z1), z5, z4)))), SUBST(V(z1), z5, App(z2, App(z3, z4)))) by 
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))

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

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](z0, Lam(z1, App(z2, Lam(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), z5, Lam(z3, z4)))), SUBST(V(z1), z5, App(z2, Lam(z3, z4))))
   RED[LET][LET](z0, Lam(z1, App(z2, V(z3))), z4) -> c8(RED(App(subst(V(z1), z4, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), z4, V(z3)))), SUBST(V(z1), z4, App(z2, V(z3))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(App(z2, z3), z4)), y0) -> c8(RED(mkapp(mkapp(subst(V(z1), y0, z2), subst(V(z1), y0, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(App(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1


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

(85) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace RED[LET][LET](z0, Lam(z1, App(z2, Lam(z3, z4))), z5) -> c8(RED(App(subst(V(z1), z5, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), z5, Lam(z3, z4)))), SUBST(V(z1), z5, App(z2, Lam(z3, z4)))) by 
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))

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

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](z0, Lam(z1, App(z2, V(z3))), z4) -> c8(RED(App(subst(V(z1), z4, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), z4, V(z3)))), SUBST(V(z1), z4, App(z2, V(z3))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(App(z2, z3), z4)), y0) -> c8(RED(mkapp(mkapp(subst(V(z1), y0, z2), subst(V(z1), y0, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(App(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1


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

(87) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace RED[LET][LET](z0, Lam(z1, App(z2, V(z3))), z4) -> c8(RED(App(subst(V(z1), z4, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), z4, V(z3)))), SUBST(V(z1), z4, App(z2, V(z3)))) by 
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))

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

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(App(z2, z3), z4)), y0) -> c8(RED(mkapp(mkapp(subst(V(z1), y0, z2), subst(V(z1), y0, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(App(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1


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

(89) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace RED[LET][LET](App(x0, x1), Lam(z1, App(App(z2, z3), z4)), y0) -> c8(RED(mkapp(mkapp(subst(V(z1), y0, z2), subst(V(z1), y0, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(App(z2, z3), z4))) by RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
----------------------------------------

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2))
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1


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

(91) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SUBST(z0, z1, App(z2, z3)) -> c16(SUBST(z0, z1, z2)) by 
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))

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

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1


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

(93) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace RED[LET][LET](App(x0, x1), Lam(z1, App(Lam(z2, z3), z4)), y0) -> c8(RED(mkapp(subst[True][Ite](eqTerm(V(z1), V(z2)), V(z1), y0, Lam(z2, z3)), subst(V(z1), y0, z4))), SUBST(V(z1), y0, App(Lam(z2, z3), z4))) by RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
----------------------------------------

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3))
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1


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

(95) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SUBST(z0, z1, App(z2, z3)) -> c17(SUBST(z0, z1, z3)) by 
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))

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

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2)))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, EQTERM_2, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c19_1, c23_1, c24_1, c28_1, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1


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

(97) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SUBST(z0, z1, V(z2)) -> c19(EQTERM(z0, V(z2))) by 
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))

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

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, EQTERM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c23_1, c24_1, c28_1, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1, c19_1


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

(99) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace EQTERM(App(z0, z1), App(z2, z3)) -> c23(EQTERM(z0, z2)) by 
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))

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

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, EQTERM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c24_1, c28_1, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1


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

(101) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace RED[LET][LET](App(x0, x1), Lam(z1, App(V(z2), z3)), y0) -> c8(RED(mkapp(subst[Ite](eqTerm(V(z1), V(z2)), V(z1), y0, V(z2)), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(V(z2), z3))) by RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
----------------------------------------

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, EQTERM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c24_1, c28_1, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1


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

(103) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace EQTERM(App(z0, z1), App(z2, z3)) -> c24(EQTERM(z1, z3)) by 
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))

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

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2))
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, EQTERM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c28_1, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1


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

(105) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c28(!EQ'(z0, z2)) by 
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))

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

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, EQTERM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1


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

(107) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace RED[LET][LET](App(x0, x1), Lam(z1, App(z2, App(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), mkapp(subst(V(z1), y0, z3), subst(V(z1), y0, z4)))), SUBST(V(z1), y0, App(z2, App(z3, z4)))) by RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
----------------------------------------

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4))))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, EQTERM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1


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

(109) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace RED[LET][LET](App(x0, x1), Lam(z1, App(z2, Lam(z3, z4))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[True][Ite](eqTerm(V(z1), V(z3)), V(z1), y0, Lam(z3, z4)))), SUBST(V(z1), y0, App(z2, Lam(z3, z4)))) by RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
----------------------------------------

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, EQTERM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1


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

(111) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace RED[LET][LET](App(x0, x1), Lam(z1, App(z2, V(z3))), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst[Ite](eqTerm(V(z1), V(z3)), V(z1), y0, V(z3)))), SUBST(V(z1), y0, App(z2, V(z3)))) by RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
----------------------------------------

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, EQTERM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1


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

(113) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(mkapp(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5))) by RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(App(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
----------------------------------------

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(App(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, EQTERM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c29_1, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1


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

(115) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace EQTERM(Lam(z0, z1), Lam(z2, z3)) -> c29(EQTERM(z1, z3)) by 
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))

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

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(App(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2, EQTERM_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1


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

(117) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SUBST(V(x0), x1, Lam(x2, x3)) -> c18(EQTERM(V(x0), V(x2))) by 
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))

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

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(App(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2, EQTERM_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1


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

(119) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](eqTerm(V(z2), V(z3)), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5))) by RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](!EQ(z2, z3), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
----------------------------------------

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(App(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](!EQ(z2, z3), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, !EQ'_2, EQTERM_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c18_1, c18_2, c11_2, c8_2, c4_1, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1


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

(121) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace !EQ'(S(S(y0)), S(S(y1))) -> c4(!EQ'(S(y0), S(y1))) by 
   !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c4(!EQ'(S(S(y0)), S(S(y1))))

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

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(App(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](!EQ(z2, z3), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c4(!EQ'(S(S(y0)), S(S(y1))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, EQTERM_2, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c18_1, c18_2, c11_2, c8_2, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c4_1


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

(123) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](eqTerm(V(z2), V(z3)), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4))) by RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](!EQ(z2, z3), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
----------------------------------------

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(App(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](!EQ(z2, z3), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c4(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](!EQ(z2, z3), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
K tuples:
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, EQTERM_2, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c18_1, c18_2, c11_2, c8_2, c33_1, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c4_1


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

(125) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace EQTERM(V(S(S(y0))), V(S(S(y1)))) -> c33(!EQ'(S(S(y0)), S(S(y1)))) by 
   EQTERM(V(S(S(S(y0)))), V(S(S(S(y1))))) -> c33(!EQ'(S(S(S(y0))), S(S(S(y1)))))

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

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(App(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](!EQ(z2, z3), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c4(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](!EQ(z2, z3), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(V(S(S(S(y0)))), V(S(S(S(y1))))) -> c33(!EQ'(S(S(S(y0))), S(S(S(y1)))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(V(S(S(S(y0)))), V(S(S(S(y1))))) -> c33(!EQ'(S(S(S(y0))), S(S(S(y1)))))
K tuples:
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, EQTERM_2, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c18_1, c18_2, c11_2, c8_2, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c4_1, c33_1


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

(127) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(SUBST(V(z1), y0, App(z2, z3))) by 
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(y2, y3), z4)), z5) -> c8(SUBST(V(z2), z5, App(App(y2, y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(y2), z4)), z5) -> c8(SUBST(V(z2), z5, App(V(y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(Lam(S(y2), y3), z4)), z5) -> c8(SUBST(V(S(y0)), z5, App(Lam(S(y2), y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(y2, y3), z4)), z5) -> c8(SUBST(V(z2), z5, App(Lam(y2, y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(0, App(Lam(S(y1), y2), z4)), z5) -> c8(SUBST(V(0), z5, App(Lam(S(y1), y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(Lam(0, y2), z4)), z5) -> c8(SUBST(V(S(y0)), z5, App(Lam(0, y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(0, App(Lam(0, y1), z4)), z5) -> c8(SUBST(V(0), z5, App(Lam(0, y1), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(y3, y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(y3, y4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(y3))), z5) -> c8(SUBST(V(z2), z5, App(z3, V(y3))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, Lam(S(y3), y4))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, Lam(S(y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(y3, y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, Lam(y3, y4))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, Lam(S(y2), y3))), z5) -> c8(SUBST(V(0), z5, App(z3, Lam(S(y2), y3))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, Lam(0, y3))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, Lam(0, y3))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, Lam(0, y2))), z5) -> c8(SUBST(V(0), z5, App(z3, Lam(0, y2))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(App(y3, y4), y5))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(App(y3, y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(V(y3), y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(V(y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, App(Lam(S(y3), y4), y5))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, App(Lam(S(y3), y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(Lam(y3, y4), y5))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(Lam(y3, y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, App(Lam(S(y2), y3), y4))), z5) -> c8(SUBST(V(0), z5, App(z3, App(Lam(S(y2), y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, App(Lam(0, y3), y4))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, App(Lam(0, y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, App(Lam(0, y2), y3))), z5) -> c8(SUBST(V(0), z5, App(z3, App(Lam(0, y2), y3))))

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

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(App(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](!EQ(z2, z3), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c4(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](!EQ(z2, z3), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(V(S(S(S(y0)))), V(S(S(S(y1))))) -> c33(!EQ'(S(S(S(y0))), S(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(y2, y3), z4)), z5) -> c8(SUBST(V(z2), z5, App(App(y2, y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(y2), z4)), z5) -> c8(SUBST(V(z2), z5, App(V(y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(Lam(S(y2), y3), z4)), z5) -> c8(SUBST(V(S(y0)), z5, App(Lam(S(y2), y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(y2, y3), z4)), z5) -> c8(SUBST(V(z2), z5, App(Lam(y2, y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(0, App(Lam(S(y1), y2), z4)), z5) -> c8(SUBST(V(0), z5, App(Lam(S(y1), y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(Lam(0, y2), z4)), z5) -> c8(SUBST(V(S(y0)), z5, App(Lam(0, y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(0, App(Lam(0, y1), z4)), z5) -> c8(SUBST(V(0), z5, App(Lam(0, y1), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(y3, y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(y3, y4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(y3))), z5) -> c8(SUBST(V(z2), z5, App(z3, V(y3))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, Lam(S(y3), y4))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, Lam(S(y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(y3, y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, Lam(y3, y4))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, Lam(S(y2), y3))), z5) -> c8(SUBST(V(0), z5, App(z3, Lam(S(y2), y3))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, Lam(0, y3))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, Lam(0, y3))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, Lam(0, y2))), z5) -> c8(SUBST(V(0), z5, App(z3, Lam(0, y2))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(App(y3, y4), y5))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(App(y3, y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(V(y3), y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(V(y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, App(Lam(S(y3), y4), y5))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, App(Lam(S(y3), y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(Lam(y3, y4), y5))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(Lam(y3, y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, App(Lam(S(y2), y3), y4))), z5) -> c8(SUBST(V(0), z5, App(z3, App(Lam(S(y2), y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, App(Lam(0, y3), y4))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, App(Lam(0, y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, App(Lam(0, y2), y3))), z5) -> c8(SUBST(V(0), z5, App(z3, App(Lam(0, y2), y3))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(V(S(S(S(y0)))), V(S(S(S(y1))))) -> c33(!EQ'(S(S(S(y0))), S(S(S(y1)))))
K tuples:
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, EQTERM_2, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c18_1, c18_2, c11_2, c8_2, c18, c8_1, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c4_1, c33_1


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

(129) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(SUBST(V(z1), y0, V(z2))) by 
   RED[LET][LET](App(z0, z1), Lam(S(S(y0)), V(S(S(y2)))), z4) -> c8(SUBST(V(S(S(y0))), z4, V(S(S(y2)))))

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

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(App(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](!EQ(z2, z3), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c4(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](!EQ(z2, z3), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(V(S(S(S(y0)))), V(S(S(S(y1))))) -> c33(!EQ'(S(S(S(y0))), S(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(y2, y3), z4)), z5) -> c8(SUBST(V(z2), z5, App(App(y2, y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(y2), z4)), z5) -> c8(SUBST(V(z2), z5, App(V(y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(Lam(S(y2), y3), z4)), z5) -> c8(SUBST(V(S(y0)), z5, App(Lam(S(y2), y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(y2, y3), z4)), z5) -> c8(SUBST(V(z2), z5, App(Lam(y2, y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(0, App(Lam(S(y1), y2), z4)), z5) -> c8(SUBST(V(0), z5, App(Lam(S(y1), y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(Lam(0, y2), z4)), z5) -> c8(SUBST(V(S(y0)), z5, App(Lam(0, y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(0, App(Lam(0, y1), z4)), z5) -> c8(SUBST(V(0), z5, App(Lam(0, y1), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(y3, y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(y3, y4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(y3))), z5) -> c8(SUBST(V(z2), z5, App(z3, V(y3))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, Lam(S(y3), y4))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, Lam(S(y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(y3, y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, Lam(y3, y4))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, Lam(S(y2), y3))), z5) -> c8(SUBST(V(0), z5, App(z3, Lam(S(y2), y3))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, Lam(0, y3))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, Lam(0, y3))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, Lam(0, y2))), z5) -> c8(SUBST(V(0), z5, App(z3, Lam(0, y2))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(App(y3, y4), y5))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(App(y3, y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(V(y3), y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(V(y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, App(Lam(S(y3), y4), y5))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, App(Lam(S(y3), y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(Lam(y3, y4), y5))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(Lam(y3, y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, App(Lam(S(y2), y3), y4))), z5) -> c8(SUBST(V(0), z5, App(z3, App(Lam(S(y2), y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, App(Lam(0, y3), y4))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, App(Lam(0, y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, App(Lam(0, y2), y3))), z5) -> c8(SUBST(V(0), z5, App(z3, App(Lam(0, y2), y3))))
   RED[LET][LET](App(z0, z1), Lam(S(S(y0)), V(S(S(y2)))), z4) -> c8(SUBST(V(S(S(y0))), z4, V(S(S(y2)))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(V(S(S(S(y0)))), V(S(S(S(y1))))) -> c33(!EQ'(S(S(S(y0))), S(S(S(y1)))))
K tuples:
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, EQTERM_2, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c18_1, c18_2, c11_2, c8_2, c18, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c4_1, c33_1, c8_1


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

(131) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SUBST(z0, z1, App(App(y2, y3), z3)) -> c16(SUBST(z0, z1, App(y2, y3))) by 
   SUBST(z0, z1, App(App(App(y2, y3), z3), z4)) -> c16(SUBST(z0, z1, App(App(y2, y3), z3)))
   SUBST(z0, z1, App(App(V(y2), z3), z4)) -> c16(SUBST(z0, z1, App(V(y2), z3)))
   SUBST(App(y0, y1), z1, App(App(Lam(y3, y4), z3), z4)) -> c16(SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)))
   SUBST(Lam(y0, y1), z1, App(App(Lam(y3, y4), z3), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)))
   SUBST(V(S(y0)), z1, App(App(Lam(S(y2), y3), z3), z4)) -> c16(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)))
   SUBST(V(y0), z1, App(App(Lam(y2, y3), z3), z4)) -> c16(SUBST(V(y0), z1, App(Lam(y2, y3), z3)))
   SUBST(V(0), z1, App(App(Lam(S(y1), y2), z3), z4)) -> c16(SUBST(V(0), z1, App(Lam(S(y1), y2), z3)))
   SUBST(V(S(y0)), z1, App(App(Lam(0, y2), z3), z4)) -> c16(SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)))
   SUBST(V(0), z1, App(App(Lam(0, y1), z3), z4)) -> c16(SUBST(V(0), z1, App(Lam(0, y1), z3)))
   SUBST(z0, z1, App(App(z2, App(y3, y4)), z4)) -> c16(SUBST(z0, z1, App(z2, App(y3, y4))))
   SUBST(z0, z1, App(App(z2, V(y3)), z4)) -> c16(SUBST(z0, z1, App(z2, V(y3))))
   SUBST(App(y0, y1), z1, App(App(z2, Lam(y4, y5)), z4)) -> c16(SUBST(App(y0, y1), z1, App(z2, Lam(y4, y5))))
   SUBST(Lam(y0, y1), z1, App(App(z2, Lam(y4, y5)), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(z2, Lam(y4, y5))))
   SUBST(V(S(y0)), z1, App(App(z2, Lam(S(y3), y4)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, Lam(S(y3), y4))))
   SUBST(V(y0), z1, App(App(z2, Lam(y3, y4)), z4)) -> c16(SUBST(V(y0), z1, App(z2, Lam(y3, y4))))
   SUBST(V(0), z1, App(App(z2, Lam(S(y2), y3)), z4)) -> c16(SUBST(V(0), z1, App(z2, Lam(S(y2), y3))))
   SUBST(V(S(y0)), z1, App(App(z2, Lam(0, y3)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, Lam(0, y3))))
   SUBST(V(0), z1, App(App(z2, Lam(0, y2)), z4)) -> c16(SUBST(V(0), z1, App(z2, Lam(0, y2))))
   SUBST(z0, z1, App(App(z2, App(App(y3, y4), y5)), z4)) -> c16(SUBST(z0, z1, App(z2, App(App(y3, y4), y5))))
   SUBST(z0, z1, App(App(z2, App(V(y3), y4)), z4)) -> c16(SUBST(z0, z1, App(z2, App(V(y3), y4))))
   SUBST(App(y0, y1), z1, App(App(z2, App(Lam(y4, y5), y6)), z4)) -> c16(SUBST(App(y0, y1), z1, App(z2, App(Lam(y4, y5), y6))))
   SUBST(Lam(y0, y1), z1, App(App(z2, App(Lam(y4, y5), y6)), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y4, y5), y6))))
   SUBST(V(S(y0)), z1, App(App(z2, App(Lam(S(y3), y4), y5)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y3), y4), y5))))
   SUBST(V(y0), z1, App(App(z2, App(Lam(y3, y4), y5)), z4)) -> c16(SUBST(V(y0), z1, App(z2, App(Lam(y3, y4), y5))))
   SUBST(V(0), z1, App(App(z2, App(Lam(S(y2), y3), y4)), z4)) -> c16(SUBST(V(0), z1, App(z2, App(Lam(S(y2), y3), y4))))
   SUBST(V(S(y0)), z1, App(App(z2, App(Lam(0, y3), y4)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y3), y4))))
   SUBST(V(0), z1, App(App(z2, App(Lam(0, y2), y3)), z4)) -> c16(SUBST(V(0), z1, App(z2, App(Lam(0, y2), y3))))

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

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(App(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](!EQ(z2, z3), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c4(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](!EQ(z2, z3), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(V(S(S(S(y0)))), V(S(S(S(y1))))) -> c33(!EQ'(S(S(S(y0))), S(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(y2, y3), z4)), z5) -> c8(SUBST(V(z2), z5, App(App(y2, y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(y2), z4)), z5) -> c8(SUBST(V(z2), z5, App(V(y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(Lam(S(y2), y3), z4)), z5) -> c8(SUBST(V(S(y0)), z5, App(Lam(S(y2), y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(y2, y3), z4)), z5) -> c8(SUBST(V(z2), z5, App(Lam(y2, y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(0, App(Lam(S(y1), y2), z4)), z5) -> c8(SUBST(V(0), z5, App(Lam(S(y1), y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(Lam(0, y2), z4)), z5) -> c8(SUBST(V(S(y0)), z5, App(Lam(0, y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(0, App(Lam(0, y1), z4)), z5) -> c8(SUBST(V(0), z5, App(Lam(0, y1), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(y3, y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(y3, y4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(y3))), z5) -> c8(SUBST(V(z2), z5, App(z3, V(y3))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, Lam(S(y3), y4))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, Lam(S(y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(y3, y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, Lam(y3, y4))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, Lam(S(y2), y3))), z5) -> c8(SUBST(V(0), z5, App(z3, Lam(S(y2), y3))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, Lam(0, y3))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, Lam(0, y3))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, Lam(0, y2))), z5) -> c8(SUBST(V(0), z5, App(z3, Lam(0, y2))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(App(y3, y4), y5))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(App(y3, y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(V(y3), y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(V(y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, App(Lam(S(y3), y4), y5))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, App(Lam(S(y3), y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(Lam(y3, y4), y5))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(Lam(y3, y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, App(Lam(S(y2), y3), y4))), z5) -> c8(SUBST(V(0), z5, App(z3, App(Lam(S(y2), y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, App(Lam(0, y3), y4))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, App(Lam(0, y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, App(Lam(0, y2), y3))), z5) -> c8(SUBST(V(0), z5, App(z3, App(Lam(0, y2), y3))))
   RED[LET][LET](App(z0, z1), Lam(S(S(y0)), V(S(S(y2)))), z4) -> c8(SUBST(V(S(S(y0))), z4, V(S(S(y2)))))
   SUBST(z0, z1, App(App(App(y2, y3), z3), z4)) -> c16(SUBST(z0, z1, App(App(y2, y3), z3)))
   SUBST(z0, z1, App(App(V(y2), z3), z4)) -> c16(SUBST(z0, z1, App(V(y2), z3)))
   SUBST(App(y0, y1), z1, App(App(Lam(y3, y4), z3), z4)) -> c16(SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)))
   SUBST(Lam(y0, y1), z1, App(App(Lam(y3, y4), z3), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)))
   SUBST(V(S(y0)), z1, App(App(Lam(S(y2), y3), z3), z4)) -> c16(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)))
   SUBST(V(y0), z1, App(App(Lam(y2, y3), z3), z4)) -> c16(SUBST(V(y0), z1, App(Lam(y2, y3), z3)))
   SUBST(V(0), z1, App(App(Lam(S(y1), y2), z3), z4)) -> c16(SUBST(V(0), z1, App(Lam(S(y1), y2), z3)))
   SUBST(V(S(y0)), z1, App(App(Lam(0, y2), z3), z4)) -> c16(SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)))
   SUBST(V(0), z1, App(App(Lam(0, y1), z3), z4)) -> c16(SUBST(V(0), z1, App(Lam(0, y1), z3)))
   SUBST(z0, z1, App(App(z2, App(y3, y4)), z4)) -> c16(SUBST(z0, z1, App(z2, App(y3, y4))))
   SUBST(z0, z1, App(App(z2, V(y3)), z4)) -> c16(SUBST(z0, z1, App(z2, V(y3))))
   SUBST(App(y0, y1), z1, App(App(z2, Lam(y4, y5)), z4)) -> c16(SUBST(App(y0, y1), z1, App(z2, Lam(y4, y5))))
   SUBST(Lam(y0, y1), z1, App(App(z2, Lam(y4, y5)), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(z2, Lam(y4, y5))))
   SUBST(V(S(y0)), z1, App(App(z2, Lam(S(y3), y4)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, Lam(S(y3), y4))))
   SUBST(V(y0), z1, App(App(z2, Lam(y3, y4)), z4)) -> c16(SUBST(V(y0), z1, App(z2, Lam(y3, y4))))
   SUBST(V(0), z1, App(App(z2, Lam(S(y2), y3)), z4)) -> c16(SUBST(V(0), z1, App(z2, Lam(S(y2), y3))))
   SUBST(V(S(y0)), z1, App(App(z2, Lam(0, y3)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, Lam(0, y3))))
   SUBST(V(0), z1, App(App(z2, Lam(0, y2)), z4)) -> c16(SUBST(V(0), z1, App(z2, Lam(0, y2))))
   SUBST(z0, z1, App(App(z2, App(App(y3, y4), y5)), z4)) -> c16(SUBST(z0, z1, App(z2, App(App(y3, y4), y5))))
   SUBST(z0, z1, App(App(z2, App(V(y3), y4)), z4)) -> c16(SUBST(z0, z1, App(z2, App(V(y3), y4))))
   SUBST(App(y0, y1), z1, App(App(z2, App(Lam(y4, y5), y6)), z4)) -> c16(SUBST(App(y0, y1), z1, App(z2, App(Lam(y4, y5), y6))))
   SUBST(Lam(y0, y1), z1, App(App(z2, App(Lam(y4, y5), y6)), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y4, y5), y6))))
   SUBST(V(S(y0)), z1, App(App(z2, App(Lam(S(y3), y4), y5)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y3), y4), y5))))
   SUBST(V(y0), z1, App(App(z2, App(Lam(y3, y4), y5)), z4)) -> c16(SUBST(V(y0), z1, App(z2, App(Lam(y3, y4), y5))))
   SUBST(V(0), z1, App(App(z2, App(Lam(S(y2), y3), y4)), z4)) -> c16(SUBST(V(0), z1, App(z2, App(Lam(S(y2), y3), y4))))
   SUBST(V(S(y0)), z1, App(App(z2, App(Lam(0, y3), y4)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y3), y4))))
   SUBST(V(0), z1, App(App(z2, App(Lam(0, y2), y3)), z4)) -> c16(SUBST(V(0), z1, App(z2, App(Lam(0, y2), y3))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(V(S(S(S(y0)))), V(S(S(S(y1))))) -> c33(!EQ'(S(S(S(y0))), S(S(S(y1)))))
   SUBST(z0, z1, App(App(App(y2, y3), z3), z4)) -> c16(SUBST(z0, z1, App(App(y2, y3), z3)))
   SUBST(z0, z1, App(App(V(y2), z3), z4)) -> c16(SUBST(z0, z1, App(V(y2), z3)))
   SUBST(App(y0, y1), z1, App(App(Lam(y3, y4), z3), z4)) -> c16(SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)))
   SUBST(Lam(y0, y1), z1, App(App(Lam(y3, y4), z3), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)))
   SUBST(V(S(y0)), z1, App(App(Lam(S(y2), y3), z3), z4)) -> c16(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)))
   SUBST(V(y0), z1, App(App(Lam(y2, y3), z3), z4)) -> c16(SUBST(V(y0), z1, App(Lam(y2, y3), z3)))
   SUBST(V(0), z1, App(App(Lam(S(y1), y2), z3), z4)) -> c16(SUBST(V(0), z1, App(Lam(S(y1), y2), z3)))
   SUBST(V(S(y0)), z1, App(App(Lam(0, y2), z3), z4)) -> c16(SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)))
   SUBST(V(0), z1, App(App(Lam(0, y1), z3), z4)) -> c16(SUBST(V(0), z1, App(Lam(0, y1), z3)))
   SUBST(z0, z1, App(App(z2, App(y3, y4)), z4)) -> c16(SUBST(z0, z1, App(z2, App(y3, y4))))
   SUBST(z0, z1, App(App(z2, V(y3)), z4)) -> c16(SUBST(z0, z1, App(z2, V(y3))))
   SUBST(App(y0, y1), z1, App(App(z2, Lam(y4, y5)), z4)) -> c16(SUBST(App(y0, y1), z1, App(z2, Lam(y4, y5))))
   SUBST(Lam(y0, y1), z1, App(App(z2, Lam(y4, y5)), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(z2, Lam(y4, y5))))
   SUBST(V(S(y0)), z1, App(App(z2, Lam(S(y3), y4)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, Lam(S(y3), y4))))
   SUBST(V(y0), z1, App(App(z2, Lam(y3, y4)), z4)) -> c16(SUBST(V(y0), z1, App(z2, Lam(y3, y4))))
   SUBST(V(0), z1, App(App(z2, Lam(S(y2), y3)), z4)) -> c16(SUBST(V(0), z1, App(z2, Lam(S(y2), y3))))
   SUBST(V(S(y0)), z1, App(App(z2, Lam(0, y3)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, Lam(0, y3))))
   SUBST(V(0), z1, App(App(z2, Lam(0, y2)), z4)) -> c16(SUBST(V(0), z1, App(z2, Lam(0, y2))))
   SUBST(z0, z1, App(App(z2, App(App(y3, y4), y5)), z4)) -> c16(SUBST(z0, z1, App(z2, App(App(y3, y4), y5))))
   SUBST(z0, z1, App(App(z2, App(V(y3), y4)), z4)) -> c16(SUBST(z0, z1, App(z2, App(V(y3), y4))))
   SUBST(App(y0, y1), z1, App(App(z2, App(Lam(y4, y5), y6)), z4)) -> c16(SUBST(App(y0, y1), z1, App(z2, App(Lam(y4, y5), y6))))
   SUBST(Lam(y0, y1), z1, App(App(z2, App(Lam(y4, y5), y6)), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y4, y5), y6))))
   SUBST(V(S(y0)), z1, App(App(z2, App(Lam(S(y3), y4), y5)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y3), y4), y5))))
   SUBST(V(y0), z1, App(App(z2, App(Lam(y3, y4), y5)), z4)) -> c16(SUBST(V(y0), z1, App(z2, App(Lam(y3, y4), y5))))
   SUBST(V(0), z1, App(App(z2, App(Lam(S(y2), y3), y4)), z4)) -> c16(SUBST(V(0), z1, App(z2, App(Lam(S(y2), y3), y4))))
   SUBST(V(S(y0)), z1, App(App(z2, App(Lam(0, y3), y4)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y3), y4))))
   SUBST(V(0), z1, App(App(z2, App(Lam(0, y2), y3)), z4)) -> c16(SUBST(V(0), z1, App(z2, App(Lam(0, y2), y3))))
K tuples:
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, EQTERM_2, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c18_1, c18_2, c11_2, c8_2, c18, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c4_1, c33_1, c8_1


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

(133) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace SUBST(z0, z1, App(V(y2), z3)) -> c16(SUBST(z0, z1, V(y2))) by 
   SUBST(V(S(S(y0))), z1, App(V(S(S(y2))), z3)) -> c16(SUBST(V(S(S(y0))), z1, V(S(S(y2)))))

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

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   subst(z0, z1, App(z2, z3)) -> mkapp(subst(z0, z1, z2), subst(z0, z1, z3))
   subst(z0, z1, Lam(z2, z3)) -> subst[True][Ite](eqTerm(z0, V(z2)), z0, z1, Lam(z2, z3))
   subst(z0, z1, V(z2)) -> subst[Ite](eqTerm(z0, V(z2)), z0, z1, V(z2))
   mkapp(z0, z1) -> App(z0, z1)
   subst[True][Ite](False, z0, z1, Lam(z2, z3)) -> mklam(V(z2), subst(z0, z1, z3))
   subst[True][Ite](True, z0, z1, z2) -> z2
   eqTerm(App(z0, z1), V(z2)) -> False
   eqTerm(Lam(z0, z1), V(z2)) -> False
   eqTerm(V(z0), V(z1)) -> !EQ(z0, z1)
   !EQ(S(z0), S(z1)) -> !EQ(z0, z1)
   !EQ(0, S(z0)) -> False
   !EQ(S(z0), 0) -> False
   !EQ(0, 0) -> True
   mklam(V(z0), z1) -> Lam(z0, z1)
   subst[Ite](False, z0, z1, z2) -> z2
   subst[Ite](True, z0, z1, z2) -> z1
   red(App(z0, z1)) -> red[Let](App(z0, z1), red(z0))
   red(Lam(z0, z1)) -> Lam(z0, z1)
   red(V(z0)) -> V(z0)
   red[Let](App(z0, z1), z2) -> red[Let][Let](App(z0, z1), z2, red(z1))
   red[Let][Let](z0, Lam(z1, z2), z3) -> red(subst(V(z1), z3, z2))
   red[Let][Let](z0, App(z1, z2), z3) -> App(App(z1, z2), z3)
   red[Let][Let](z0, V(z1), z2) -> App(V(z1), z2)
Tuples:
   RED[LET](App(z0, z1), z2) -> c13(RED[LET][LET](App(z0, z1), z2, red(z1)), RED(z1))
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST[TRUE][ITE](False, App(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(App(x0, x1), x2, x4)), SUBST(App(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, Lam(x0, x1), x2, Lam(x3, x4)) -> c11(MKLAM(V(x3), subst(Lam(x0, x1), x2, x4)), SUBST(Lam(x0, x1), x2, x4))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(S(x2), x3)) -> c11(MKLAM(V(S(x2)), subst(V(S(x0)), x1, x3)), SUBST(V(S(x0)), x1, x3))
   SUBST[TRUE][ITE](False, V(0), x0, Lam(S(x1), x2)) -> c11(MKLAM(V(S(x1)), subst(V(0), x0, x2)), SUBST(V(0), x0, x2))
   SUBST[TRUE][ITE](False, V(S(x0)), x1, Lam(0, x2)) -> c11(MKLAM(V(0), subst(V(S(x0)), x1, x2)), SUBST(V(S(x0)), x1, x2))
   RED[LET][LET](App(x0, x1), Lam(z1, App(z2, z3)), y0) -> c8(RED(App(subst(V(z1), y0, z2), subst(V(z1), y0, z3))), SUBST(V(z1), y0, App(z2, z3)))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   RED[LET][LET](App(x0, x1), Lam(z1, Lam(z2, z3)), y0) -> c8(RED(subst[True][Ite](!EQ(z1, z2), V(z1), y0, Lam(z2, z3))), SUBST(V(z1), y0, Lam(z2, z3)))
   RED[LET][LET](App(x0, x1), Lam(z1, V(z2)), y0) -> c8(RED(subst[Ite](!EQ(z1, z2), V(z1), y0, V(z2))), SUBST(V(z1), y0, V(z2)))
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), App(subst(V(z2), z6, z4), subst(V(z2), z6, z5)))), SUBST(V(z2), z6, App(z3, App(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(z4, z5))), z6) -> c8(RED(App(subst(V(z2), z6, z3), subst[True][Ite](!EQ(z2, z4), V(z2), z6, Lam(z4, z5)))), SUBST(V(z2), z6, App(z3, Lam(z4, z5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(z4))), z5) -> c8(RED(App(subst(V(z2), z5, z3), subst[Ite](!EQ(z2, z4), V(z2), z5, V(z4)))), SUBST(V(z2), z5, App(z3, V(z4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(z3, z4), z5)), z6) -> c8(RED(App(App(subst(V(z2), z6, z3), subst(V(z2), z6, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(App(z3, z4), z5)))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(z3, z4), z5)), z6) -> c8(RED(App(subst[True][Ite](!EQ(z2, z3), V(z2), z6, Lam(z3, z4)), subst(V(z2), z6, z5))), SUBST(V(z2), z6, App(Lam(z3, z4), z5)))
   !EQ'(S(S(S(y0))), S(S(S(y1)))) -> c4(!EQ'(S(S(y0)), S(S(y1))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(z3), z4)), z5) -> c8(RED(App(subst[Ite](!EQ(z2, z3), V(z2), z5, V(z3)), subst(V(z2), z5, z4))), SUBST(V(z2), z5, App(V(z3), z4)))
   EQTERM(V(S(S(S(y0)))), V(S(S(S(y1))))) -> c33(!EQ'(S(S(S(y0))), S(S(S(y1)))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(App(y2, y3), z4)), z5) -> c8(SUBST(V(z2), z5, App(App(y2, y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(V(y2), z4)), z5) -> c8(SUBST(V(z2), z5, App(V(y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(Lam(S(y2), y3), z4)), z5) -> c8(SUBST(V(S(y0)), z5, App(Lam(S(y2), y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(Lam(y2, y3), z4)), z5) -> c8(SUBST(V(z2), z5, App(Lam(y2, y3), z4)))
   RED[LET][LET](App(z0, z1), Lam(0, App(Lam(S(y1), y2), z4)), z5) -> c8(SUBST(V(0), z5, App(Lam(S(y1), y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(Lam(0, y2), z4)), z5) -> c8(SUBST(V(S(y0)), z5, App(Lam(0, y2), z4)))
   RED[LET][LET](App(z0, z1), Lam(0, App(Lam(0, y1), z4)), z5) -> c8(SUBST(V(0), z5, App(Lam(0, y1), z4)))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(y3, y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(y3, y4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, V(y3))), z5) -> c8(SUBST(V(z2), z5, App(z3, V(y3))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, Lam(S(y3), y4))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, Lam(S(y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, Lam(y3, y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, Lam(y3, y4))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, Lam(S(y2), y3))), z5) -> c8(SUBST(V(0), z5, App(z3, Lam(S(y2), y3))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, Lam(0, y3))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, Lam(0, y3))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, Lam(0, y2))), z5) -> c8(SUBST(V(0), z5, App(z3, Lam(0, y2))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(App(y3, y4), y5))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(App(y3, y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(V(y3), y4))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(V(y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, App(Lam(S(y3), y4), y5))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, App(Lam(S(y3), y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(z2, App(z3, App(Lam(y3, y4), y5))), z5) -> c8(SUBST(V(z2), z5, App(z3, App(Lam(y3, y4), y5))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, App(Lam(S(y2), y3), y4))), z5) -> c8(SUBST(V(0), z5, App(z3, App(Lam(S(y2), y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(S(y0), App(z3, App(Lam(0, y3), y4))), z5) -> c8(SUBST(V(S(y0)), z5, App(z3, App(Lam(0, y3), y4))))
   RED[LET][LET](App(z0, z1), Lam(0, App(z3, App(Lam(0, y2), y3))), z5) -> c8(SUBST(V(0), z5, App(z3, App(Lam(0, y2), y3))))
   RED[LET][LET](App(z0, z1), Lam(S(S(y0)), V(S(S(y2)))), z4) -> c8(SUBST(V(S(S(y0))), z4, V(S(S(y2)))))
   SUBST(z0, z1, App(App(App(y2, y3), z3), z4)) -> c16(SUBST(z0, z1, App(App(y2, y3), z3)))
   SUBST(z0, z1, App(App(V(y2), z3), z4)) -> c16(SUBST(z0, z1, App(V(y2), z3)))
   SUBST(App(y0, y1), z1, App(App(Lam(y3, y4), z3), z4)) -> c16(SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)))
   SUBST(Lam(y0, y1), z1, App(App(Lam(y3, y4), z3), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)))
   SUBST(V(S(y0)), z1, App(App(Lam(S(y2), y3), z3), z4)) -> c16(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)))
   SUBST(V(y0), z1, App(App(Lam(y2, y3), z3), z4)) -> c16(SUBST(V(y0), z1, App(Lam(y2, y3), z3)))
   SUBST(V(0), z1, App(App(Lam(S(y1), y2), z3), z4)) -> c16(SUBST(V(0), z1, App(Lam(S(y1), y2), z3)))
   SUBST(V(S(y0)), z1, App(App(Lam(0, y2), z3), z4)) -> c16(SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)))
   SUBST(V(0), z1, App(App(Lam(0, y1), z3), z4)) -> c16(SUBST(V(0), z1, App(Lam(0, y1), z3)))
   SUBST(z0, z1, App(App(z2, App(y3, y4)), z4)) -> c16(SUBST(z0, z1, App(z2, App(y3, y4))))
   SUBST(z0, z1, App(App(z2, V(y3)), z4)) -> c16(SUBST(z0, z1, App(z2, V(y3))))
   SUBST(App(y0, y1), z1, App(App(z2, Lam(y4, y5)), z4)) -> c16(SUBST(App(y0, y1), z1, App(z2, Lam(y4, y5))))
   SUBST(Lam(y0, y1), z1, App(App(z2, Lam(y4, y5)), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(z2, Lam(y4, y5))))
   SUBST(V(S(y0)), z1, App(App(z2, Lam(S(y3), y4)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, Lam(S(y3), y4))))
   SUBST(V(y0), z1, App(App(z2, Lam(y3, y4)), z4)) -> c16(SUBST(V(y0), z1, App(z2, Lam(y3, y4))))
   SUBST(V(0), z1, App(App(z2, Lam(S(y2), y3)), z4)) -> c16(SUBST(V(0), z1, App(z2, Lam(S(y2), y3))))
   SUBST(V(S(y0)), z1, App(App(z2, Lam(0, y3)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, Lam(0, y3))))
   SUBST(V(0), z1, App(App(z2, Lam(0, y2)), z4)) -> c16(SUBST(V(0), z1, App(z2, Lam(0, y2))))
   SUBST(z0, z1, App(App(z2, App(App(y3, y4), y5)), z4)) -> c16(SUBST(z0, z1, App(z2, App(App(y3, y4), y5))))
   SUBST(z0, z1, App(App(z2, App(V(y3), y4)), z4)) -> c16(SUBST(z0, z1, App(z2, App(V(y3), y4))))
   SUBST(App(y0, y1), z1, App(App(z2, App(Lam(y4, y5), y6)), z4)) -> c16(SUBST(App(y0, y1), z1, App(z2, App(Lam(y4, y5), y6))))
   SUBST(Lam(y0, y1), z1, App(App(z2, App(Lam(y4, y5), y6)), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y4, y5), y6))))
   SUBST(V(S(y0)), z1, App(App(z2, App(Lam(S(y3), y4), y5)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y3), y4), y5))))
   SUBST(V(y0), z1, App(App(z2, App(Lam(y3, y4), y5)), z4)) -> c16(SUBST(V(y0), z1, App(z2, App(Lam(y3, y4), y5))))
   SUBST(V(0), z1, App(App(z2, App(Lam(S(y2), y3), y4)), z4)) -> c16(SUBST(V(0), z1, App(z2, App(Lam(S(y2), y3), y4))))
   SUBST(V(S(y0)), z1, App(App(z2, App(Lam(0, y3), y4)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y3), y4))))
   SUBST(V(0), z1, App(App(z2, App(Lam(0, y2), y3)), z4)) -> c16(SUBST(V(0), z1, App(z2, App(Lam(0, y2), y3))))
   SUBST(V(S(S(y0))), z1, App(V(S(S(y2))), z3)) -> c16(SUBST(V(S(S(y0))), z1, V(S(S(y2)))))
S tuples:
   RED(App(z0, z1)) -> c20(RED[LET](App(z0, z1), red(z0)), RED(z0))
   RED(Lam(z0, z1)) -> c21
   RED(V(z0)) -> c22
   MKLAM(V(z0), z1) -> c34
   SUBST(App(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, App(z0, z1), x1, Lam(z2, x3)))
   SUBST(Lam(z0, z1), x1, Lam(z2, x3)) -> c18(SUBST[TRUE][ITE](False, Lam(z0, z1), x1, Lam(z2, x3)))
   SUBST(V(S(z0)), x1, Lam(S(z1), x3)) -> c18(SUBST[TRUE][ITE](!EQ(z0, z1), V(S(z0)), x1, Lam(S(z1), x3)), EQTERM(V(S(z0)), V(S(z1))))
   SUBST(V(0), x1, Lam(S(z0), x3)) -> c18(SUBST[TRUE][ITE](False, V(0), x1, Lam(S(z0), x3)))
   SUBST(V(S(z0)), x1, Lam(0, x3)) -> c18(SUBST[TRUE][ITE](False, V(S(z0)), x1, Lam(0, x3)))
   SUBST(V(0), x1, Lam(0, x3)) -> c18
   SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)) -> c16(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(Lam(y2, y3), z3)) -> c16(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(Lam(S(y1), y2), z3)) -> c16(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)) -> c16(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(Lam(0, y1), z3)) -> c16(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(y2, y3))) -> c17(SUBST(z0, z1, App(y2, y3)))
   SUBST(z0, z1, App(z2, V(y2))) -> c17(SUBST(z0, z1, V(y2)))
   SUBST(App(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(App(y0, y1), z1, Lam(y3, y4)))
   SUBST(Lam(y0, y1), z1, App(z2, Lam(y3, y4))) -> c17(SUBST(Lam(y0, y1), z1, Lam(y3, y4)))
   SUBST(V(S(y0)), z1, App(z2, Lam(S(y2), y3))) -> c17(SUBST(V(S(y0)), z1, Lam(S(y2), y3)))
   SUBST(V(y0), z1, App(z2, Lam(y2, y3))) -> c17(SUBST(V(y0), z1, Lam(y2, y3)))
   SUBST(V(0), z1, App(z2, Lam(S(y1), y2))) -> c17(SUBST(V(0), z1, Lam(S(y1), y2)))
   SUBST(V(S(y0)), z1, App(z2, Lam(0, y2))) -> c17(SUBST(V(S(y0)), z1, Lam(0, y2)))
   SUBST(V(0), z1, App(z2, Lam(0, y1))) -> c17(SUBST(V(0), z1, Lam(0, y1)))
   SUBST(z0, z1, App(z2, App(App(y2, y3), y4))) -> c17(SUBST(z0, z1, App(App(y2, y3), y4)))
   SUBST(z0, z1, App(z2, App(V(y2), y3))) -> c17(SUBST(z0, z1, App(V(y2), y3)))
   SUBST(App(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(App(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y3, y4), y5))) -> c17(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), y5)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y2), y3), y4))) -> c17(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), y4)))
   SUBST(V(y0), z1, App(z2, App(Lam(y2, y3), y4))) -> c17(SUBST(V(y0), z1, App(Lam(y2, y3), y4)))
   SUBST(V(0), z1, App(z2, App(Lam(S(y1), y2), y3))) -> c17(SUBST(V(0), z1, App(Lam(S(y1), y2), y3)))
   SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y2), y3))) -> c17(SUBST(V(S(y0)), z1, App(Lam(0, y2), y3)))
   SUBST(V(0), z1, App(z2, App(Lam(0, y1), y2))) -> c17(SUBST(V(0), z1, App(Lam(0, y1), y2)))
   SUBST(V(S(S(y0))), z1, V(S(S(y1)))) -> c19(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   SUBST(V(S(S(y0))), z1, Lam(S(S(y1)), z3)) -> c18(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(V(S(S(S(y0)))), V(S(S(S(y1))))) -> c33(!EQ'(S(S(S(y0))), S(S(S(y1)))))
   SUBST(z0, z1, App(App(App(y2, y3), z3), z4)) -> c16(SUBST(z0, z1, App(App(y2, y3), z3)))
   SUBST(z0, z1, App(App(V(y2), z3), z4)) -> c16(SUBST(z0, z1, App(V(y2), z3)))
   SUBST(App(y0, y1), z1, App(App(Lam(y3, y4), z3), z4)) -> c16(SUBST(App(y0, y1), z1, App(Lam(y3, y4), z3)))
   SUBST(Lam(y0, y1), z1, App(App(Lam(y3, y4), z3), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(Lam(y3, y4), z3)))
   SUBST(V(S(y0)), z1, App(App(Lam(S(y2), y3), z3), z4)) -> c16(SUBST(V(S(y0)), z1, App(Lam(S(y2), y3), z3)))
   SUBST(V(y0), z1, App(App(Lam(y2, y3), z3), z4)) -> c16(SUBST(V(y0), z1, App(Lam(y2, y3), z3)))
   SUBST(V(0), z1, App(App(Lam(S(y1), y2), z3), z4)) -> c16(SUBST(V(0), z1, App(Lam(S(y1), y2), z3)))
   SUBST(V(S(y0)), z1, App(App(Lam(0, y2), z3), z4)) -> c16(SUBST(V(S(y0)), z1, App(Lam(0, y2), z3)))
   SUBST(V(0), z1, App(App(Lam(0, y1), z3), z4)) -> c16(SUBST(V(0), z1, App(Lam(0, y1), z3)))
   SUBST(z0, z1, App(App(z2, App(y3, y4)), z4)) -> c16(SUBST(z0, z1, App(z2, App(y3, y4))))
   SUBST(z0, z1, App(App(z2, V(y3)), z4)) -> c16(SUBST(z0, z1, App(z2, V(y3))))
   SUBST(App(y0, y1), z1, App(App(z2, Lam(y4, y5)), z4)) -> c16(SUBST(App(y0, y1), z1, App(z2, Lam(y4, y5))))
   SUBST(Lam(y0, y1), z1, App(App(z2, Lam(y4, y5)), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(z2, Lam(y4, y5))))
   SUBST(V(S(y0)), z1, App(App(z2, Lam(S(y3), y4)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, Lam(S(y3), y4))))
   SUBST(V(y0), z1, App(App(z2, Lam(y3, y4)), z4)) -> c16(SUBST(V(y0), z1, App(z2, Lam(y3, y4))))
   SUBST(V(0), z1, App(App(z2, Lam(S(y2), y3)), z4)) -> c16(SUBST(V(0), z1, App(z2, Lam(S(y2), y3))))
   SUBST(V(S(y0)), z1, App(App(z2, Lam(0, y3)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, Lam(0, y3))))
   SUBST(V(0), z1, App(App(z2, Lam(0, y2)), z4)) -> c16(SUBST(V(0), z1, App(z2, Lam(0, y2))))
   SUBST(z0, z1, App(App(z2, App(App(y3, y4), y5)), z4)) -> c16(SUBST(z0, z1, App(z2, App(App(y3, y4), y5))))
   SUBST(z0, z1, App(App(z2, App(V(y3), y4)), z4)) -> c16(SUBST(z0, z1, App(z2, App(V(y3), y4))))
   SUBST(App(y0, y1), z1, App(App(z2, App(Lam(y4, y5), y6)), z4)) -> c16(SUBST(App(y0, y1), z1, App(z2, App(Lam(y4, y5), y6))))
   SUBST(Lam(y0, y1), z1, App(App(z2, App(Lam(y4, y5), y6)), z4)) -> c16(SUBST(Lam(y0, y1), z1, App(z2, App(Lam(y4, y5), y6))))
   SUBST(V(S(y0)), z1, App(App(z2, App(Lam(S(y3), y4), y5)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, App(Lam(S(y3), y4), y5))))
   SUBST(V(y0), z1, App(App(z2, App(Lam(y3, y4), y5)), z4)) -> c16(SUBST(V(y0), z1, App(z2, App(Lam(y3, y4), y5))))
   SUBST(V(0), z1, App(App(z2, App(Lam(S(y2), y3), y4)), z4)) -> c16(SUBST(V(0), z1, App(z2, App(Lam(S(y2), y3), y4))))
   SUBST(V(S(y0)), z1, App(App(z2, App(Lam(0, y3), y4)), z4)) -> c16(SUBST(V(S(y0)), z1, App(z2, App(Lam(0, y3), y4))))
   SUBST(V(0), z1, App(App(z2, App(Lam(0, y2), y3)), z4)) -> c16(SUBST(V(0), z1, App(z2, App(Lam(0, y2), y3))))
   SUBST(V(S(S(y0))), z1, App(V(S(S(y2))), z3)) -> c16(SUBST(V(S(S(y0))), z1, V(S(S(y2)))))
K tuples:
   EQTERM(App(App(y0, y1), z1), App(App(y2, y3), z3)) -> c23(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(Lam(y0, y1), z1), App(Lam(y2, y3), z3)) -> c23(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(V(S(S(y0))), z1), App(V(S(S(y1))), z3)) -> c23(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(y0, y1)), App(z2, App(y2, y3))) -> c24(EQTERM(App(y0, y1), App(y2, y3)))
   EQTERM(App(z0, Lam(y0, y1)), App(z2, Lam(y2, y3))) -> c24(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(App(z0, V(S(S(y0)))), App(z2, V(S(S(y1))))) -> c24(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(App(z0, App(App(y0, y1), y2)), App(z2, App(App(y3, y4), y5))) -> c24(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(App(z0, App(Lam(y0, y1), y2)), App(z2, App(Lam(y3, y4), y5))) -> c24(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(App(z0, App(V(S(S(y0))), y1)), App(z2, App(V(S(S(y2))), y3))) -> c24(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(S(S(y0)), z1), Lam(S(S(y1)), z3)) -> c28(!EQ'(S(S(y0)), S(S(y1))))
   EQTERM(Lam(z0, Lam(y0, y1)), Lam(z2, Lam(y2, y3))) -> c29(EQTERM(Lam(y0, y1), Lam(y2, y3)))
   EQTERM(Lam(z0, V(S(S(y0)))), Lam(z2, V(S(S(y1))))) -> c29(EQTERM(V(S(S(y0))), V(S(S(y1)))))
   EQTERM(Lam(z0, App(App(y0, y1), y2)), Lam(z2, App(App(y3, y4), y5))) -> c29(EQTERM(App(App(y0, y1), y2), App(App(y3, y4), y5)))
   EQTERM(Lam(z0, App(Lam(y0, y1), y2)), Lam(z2, App(Lam(y3, y4), y5))) -> c29(EQTERM(App(Lam(y0, y1), y2), App(Lam(y3, y4), y5)))
   EQTERM(Lam(z0, App(V(S(S(y0))), y1)), Lam(z2, App(V(S(S(y2))), y3))) -> c29(EQTERM(App(V(S(S(y0))), y1), App(V(S(S(y2))), y3)))
   EQTERM(Lam(z0, App(y0, App(y1, y2))), Lam(z2, App(y3, App(y4, y5)))) -> c29(EQTERM(App(y0, App(y1, y2)), App(y3, App(y4, y5))))
   EQTERM(Lam(z0, App(y0, Lam(y1, y2))), Lam(z2, App(y3, Lam(y4, y5)))) -> c29(EQTERM(App(y0, Lam(y1, y2)), App(y3, Lam(y4, y5))))
   EQTERM(Lam(z0, App(y0, V(S(S(y1))))), Lam(z2, App(y2, V(S(S(y3)))))) -> c29(EQTERM(App(y0, V(S(S(y1)))), App(y2, V(S(S(y3))))))
   EQTERM(Lam(z0, App(y0, App(App(y1, y2), y3))), Lam(z2, App(y4, App(App(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(App(y1, y2), y3)), App(y4, App(App(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(Lam(y1, y2), y3))), Lam(z2, App(y4, App(Lam(y5, y6), y7)))) -> c29(EQTERM(App(y0, App(Lam(y1, y2), y3)), App(y4, App(Lam(y5, y6), y7))))
   EQTERM(Lam(z0, App(y0, App(V(S(S(y1))), y2))), Lam(z2, App(y3, App(V(S(S(y4))), y5)))) -> c29(EQTERM(App(y0, App(V(S(S(y1))), y2)), App(y3, App(V(S(S(y4))), y5))))
   EQTERM(Lam(z0, Lam(S(S(y0)), y1)), Lam(z2, Lam(S(S(y2)), y3))) -> c29(EQTERM(Lam(S(S(y0)), y1), Lam(S(S(y2)), y3)))
Defined Rule Symbols:   subst_3, mkapp_2, subst[True][Ite]_4, eqTerm_2, !EQ_2, mklam_2, subst[Ite]_4, red_1, red[Let]_2, red[Let][Let]_3

Defined Pair Symbols:   RED[LET]_2, RED_1, MKLAM_2, SUBST_3, SUBST[TRUE][ITE]_4, RED[LET][LET]_3, EQTERM_2, !EQ'_2

Compound Symbols:   c13_2, c20_2, c21, c22, c34, c18_1, c18_2, c11_2, c8_2, c18, c16_1, c17_1, c19_1, c23_1, c24_1, c28_1, c29_1, c4_1, c33_1, c8_1