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