/export/starexec/sandbox/solver/bin/starexec_run_FirstOrder /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- YES We consider the system theBenchmark. We are asked to determine termination of the following first-order TRS. 0 : [] --> o U11 : [o] --> o U21 : [o] --> o U31 : [o] --> o U41 : [o * o] --> o U42 : [o] --> o U51 : [o * o] --> o U52 : [o] --> o U61 : [o * o * o] --> o U62 : [o * o] --> o active : [o] --> o cons : [o * o] --> o isNat : [o] --> o isNatIList : [o] --> o isNatList : [o] --> o length : [o] --> o mark : [o] --> o nil : [] --> o s : [o] --> o tt : [] --> o zeros : [] --> o active(zeros) => mark(cons(0, zeros)) active(U11(tt)) => mark(tt) active(U21(tt)) => mark(tt) active(U31(tt)) => mark(tt) active(U41(tt, X)) => mark(U42(isNatIList(X))) active(U42(tt)) => mark(tt) active(U51(tt, X)) => mark(U52(isNatList(X))) active(U52(tt)) => mark(tt) active(U61(tt, X, Y)) => mark(U62(isNat(Y), X)) active(U62(tt, X)) => mark(s(length(X))) active(isNat(0)) => mark(tt) active(isNat(length(X))) => mark(U11(isNatList(X))) active(isNat(s(X))) => mark(U21(isNat(X))) active(isNatIList(X)) => mark(U31(isNatList(X))) active(isNatIList(zeros)) => mark(tt) active(isNatIList(cons(X, Y))) => mark(U41(isNat(X), Y)) active(isNatList(nil)) => mark(tt) active(isNatList(cons(X, Y))) => mark(U51(isNat(X), Y)) active(length(nil)) => mark(0) active(length(cons(X, Y))) => mark(U61(isNatList(Y), Y, X)) mark(zeros) => active(zeros) mark(cons(X, Y)) => active(cons(mark(X), Y)) mark(0) => active(0) mark(U11(X)) => active(U11(mark(X))) mark(tt) => active(tt) mark(U21(X)) => active(U21(mark(X))) mark(U31(X)) => active(U31(mark(X))) mark(U41(X, Y)) => active(U41(mark(X), Y)) mark(U42(X)) => active(U42(mark(X))) mark(isNatIList(X)) => active(isNatIList(X)) mark(U51(X, Y)) => active(U51(mark(X), Y)) mark(U52(X)) => active(U52(mark(X))) mark(isNatList(X)) => active(isNatList(X)) mark(U61(X, Y, Z)) => active(U61(mark(X), Y, Z)) mark(U62(X, Y)) => active(U62(mark(X), Y)) mark(isNat(X)) => active(isNat(X)) mark(s(X)) => active(s(mark(X))) mark(length(X)) => active(length(mark(X))) mark(nil) => active(nil) cons(mark(X), Y) => cons(X, Y) cons(X, mark(Y)) => cons(X, Y) cons(active(X), Y) => cons(X, Y) cons(X, active(Y)) => cons(X, Y) U11(mark(X)) => U11(X) U11(active(X)) => U11(X) U21(mark(X)) => U21(X) U21(active(X)) => U21(X) U31(mark(X)) => U31(X) U31(active(X)) => U31(X) U41(mark(X), Y) => U41(X, Y) U41(X, mark(Y)) => U41(X, Y) U41(active(X), Y) => U41(X, Y) U41(X, active(Y)) => U41(X, Y) U42(mark(X)) => U42(X) U42(active(X)) => U42(X) isNatIList(mark(X)) => isNatIList(X) isNatIList(active(X)) => isNatIList(X) U51(mark(X), Y) => U51(X, Y) U51(X, mark(Y)) => U51(X, Y) U51(active(X), Y) => U51(X, Y) U51(X, active(Y)) => U51(X, Y) U52(mark(X)) => U52(X) U52(active(X)) => U52(X) isNatList(mark(X)) => isNatList(X) isNatList(active(X)) => isNatList(X) U61(mark(X), Y, Z) => U61(X, Y, Z) U61(X, mark(Y), Z) => U61(X, Y, Z) U61(X, Y, mark(Z)) => U61(X, Y, Z) U61(active(X), Y, Z) => U61(X, Y, Z) U61(X, active(Y), Z) => U61(X, Y, Z) U61(X, Y, active(Z)) => U61(X, Y, Z) U62(mark(X), Y) => U62(X, Y) U62(X, mark(Y)) => U62(X, Y) U62(active(X), Y) => U62(X, Y) U62(X, active(Y)) => U62(X, Y) isNat(mark(X)) => isNat(X) isNat(active(X)) => isNat(X) s(mark(X)) => s(X) s(active(X)) => s(X) length(mark(X)) => length(X) length(active(X)) => length(X) We use rule removal, following [Kop12, Theorem 2.23]. This gives the following requirements (possibly using Theorems 2.25 and 2.26 in [Kop12]): active(zeros) >? mark(cons(0, zeros)) active(U11(tt)) >? mark(tt) active(U21(tt)) >? mark(tt) active(U31(tt)) >? mark(tt) active(U41(tt, X)) >? mark(U42(isNatIList(X))) active(U42(tt)) >? mark(tt) active(U51(tt, X)) >? mark(U52(isNatList(X))) active(U52(tt)) >? mark(tt) active(U61(tt, X, Y)) >? mark(U62(isNat(Y), X)) active(U62(tt, X)) >? mark(s(length(X))) active(isNat(0)) >? mark(tt) active(isNat(length(X))) >? mark(U11(isNatList(X))) active(isNat(s(X))) >? mark(U21(isNat(X))) active(isNatIList(X)) >? mark(U31(isNatList(X))) active(isNatIList(zeros)) >? mark(tt) active(isNatIList(cons(X, Y))) >? mark(U41(isNat(X), Y)) active(isNatList(nil)) >? mark(tt) active(isNatList(cons(X, Y))) >? mark(U51(isNat(X), Y)) active(length(nil)) >? mark(0) active(length(cons(X, Y))) >? mark(U61(isNatList(Y), Y, X)) mark(zeros) >? active(zeros) mark(cons(X, Y)) >? active(cons(mark(X), Y)) mark(0) >? active(0) mark(U11(X)) >? active(U11(mark(X))) mark(tt) >? active(tt) mark(U21(X)) >? active(U21(mark(X))) mark(U31(X)) >? active(U31(mark(X))) mark(U41(X, Y)) >? active(U41(mark(X), Y)) mark(U42(X)) >? active(U42(mark(X))) mark(isNatIList(X)) >? active(isNatIList(X)) mark(U51(X, Y)) >? active(U51(mark(X), Y)) mark(U52(X)) >? active(U52(mark(X))) mark(isNatList(X)) >? active(isNatList(X)) mark(U61(X, Y, Z)) >? active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >? active(U62(mark(X), Y)) mark(isNat(X)) >? active(isNat(X)) mark(s(X)) >? active(s(mark(X))) mark(length(X)) >? active(length(mark(X))) mark(nil) >? active(nil) cons(mark(X), Y) >? cons(X, Y) cons(X, mark(Y)) >? cons(X, Y) cons(active(X), Y) >? cons(X, Y) cons(X, active(Y)) >? cons(X, Y) U11(mark(X)) >? U11(X) U11(active(X)) >? U11(X) U21(mark(X)) >? U21(X) U21(active(X)) >? U21(X) U31(mark(X)) >? U31(X) U31(active(X)) >? U31(X) U41(mark(X), Y) >? U41(X, Y) U41(X, mark(Y)) >? U41(X, Y) U41(active(X), Y) >? U41(X, Y) U41(X, active(Y)) >? U41(X, Y) U42(mark(X)) >? U42(X) U42(active(X)) >? U42(X) isNatIList(mark(X)) >? isNatIList(X) isNatIList(active(X)) >? isNatIList(X) U51(mark(X), Y) >? U51(X, Y) U51(X, mark(Y)) >? U51(X, Y) U51(active(X), Y) >? U51(X, Y) U51(X, active(Y)) >? U51(X, Y) U52(mark(X)) >? U52(X) U52(active(X)) >? U52(X) isNatList(mark(X)) >? isNatList(X) isNatList(active(X)) >? isNatList(X) U61(mark(X), Y, Z) >? U61(X, Y, Z) U61(X, mark(Y), Z) >? U61(X, Y, Z) U61(X, Y, mark(Z)) >? U61(X, Y, Z) U61(active(X), Y, Z) >? U61(X, Y, Z) U61(X, active(Y), Z) >? U61(X, Y, Z) U61(X, Y, active(Z)) >? U61(X, Y, Z) U62(mark(X), Y) >? U62(X, Y) U62(X, mark(Y)) >? U62(X, Y) U62(active(X), Y) >? U62(X, Y) U62(X, active(Y)) >? U62(X, Y) isNat(mark(X)) >? isNat(X) isNat(active(X)) >? isNat(X) s(mark(X)) >? s(X) s(active(X)) >? s(X) length(mark(X)) >? length(X) length(active(X)) >? length(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.y0 U21 = \y0.y0 U31 = \y0.y0 U41 = \y0y1.y0 + 2y1 U42 = \y0.y0 U51 = \y0y1.y0 + y1 U52 = \y0.y0 U61 = \y0y1y2.y0 + 2y1 + 2y2 U62 = \y0y1.2y0 + 2y1 active = \y0.y0 cons = \y0y1.y0 + 2y1 isNat = \y0.y0 isNatIList = \y0.2y0 isNatList = \y0.y0 length = \y0.2y0 mark = \y0.y0 nil = 1 s = \y0.y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active(zeros)]] = 0 >= 0 = [[mark(cons(0, zeros))]] [[active(U11(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U21(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U31(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U41(tt, _x0))]] = 2x0 >= 2x0 = [[mark(U42(isNatIList(_x0)))]] [[active(U42(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U51(tt, _x0))]] = x0 >= x0 = [[mark(U52(isNatList(_x0)))]] [[active(U52(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U61(tt, _x0, _x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[mark(U62(isNat(_x1), _x0))]] [[active(U62(tt, _x0))]] = 2x0 >= 2x0 = [[mark(s(length(_x0)))]] [[active(isNat(0))]] = 0 >= 0 = [[mark(tt)]] [[active(isNat(length(_x0)))]] = 2x0 >= x0 = [[mark(U11(isNatList(_x0)))]] [[active(isNat(s(_x0)))]] = x0 >= x0 = [[mark(U21(isNat(_x0)))]] [[active(isNatIList(_x0))]] = 2x0 >= x0 = [[mark(U31(isNatList(_x0)))]] [[active(isNatIList(zeros))]] = 0 >= 0 = [[mark(tt)]] [[active(isNatIList(cons(_x0, _x1)))]] = 2x0 + 4x1 >= x0 + 2x1 = [[mark(U41(isNat(_x0), _x1))]] [[active(isNatList(nil))]] = 1 > 0 = [[mark(tt)]] [[active(isNatList(cons(_x0, _x1)))]] = x0 + 2x1 >= x0 + x1 = [[mark(U51(isNat(_x0), _x1))]] [[active(length(nil))]] = 2 > 0 = [[mark(0)]] [[active(length(cons(_x0, _x1)))]] = 2x0 + 4x1 >= 2x0 + 3x1 = [[mark(U61(isNatList(_x1), _x1, _x0))]] [[mark(zeros)]] = 0 >= 0 = [[active(zeros)]] [[mark(cons(_x0, _x1))]] = x0 + 2x1 >= x0 + 2x1 = [[active(cons(mark(_x0), _x1))]] [[mark(0)]] = 0 >= 0 = [[active(0)]] [[mark(U11(_x0))]] = x0 >= x0 = [[active(U11(mark(_x0)))]] [[mark(tt)]] = 0 >= 0 = [[active(tt)]] [[mark(U21(_x0))]] = x0 >= x0 = [[active(U21(mark(_x0)))]] [[mark(U31(_x0))]] = x0 >= x0 = [[active(U31(mark(_x0)))]] [[mark(U41(_x0, _x1))]] = x0 + 2x1 >= x0 + 2x1 = [[active(U41(mark(_x0), _x1))]] [[mark(U42(_x0))]] = x0 >= x0 = [[active(U42(mark(_x0)))]] [[mark(isNatIList(_x0))]] = 2x0 >= 2x0 = [[active(isNatIList(_x0))]] [[mark(U51(_x0, _x1))]] = x0 + x1 >= x0 + x1 = [[active(U51(mark(_x0), _x1))]] [[mark(U52(_x0))]] = x0 >= x0 = [[active(U52(mark(_x0)))]] [[mark(isNatList(_x0))]] = x0 >= x0 = [[active(isNatList(_x0))]] [[mark(U61(_x0, _x1, _x2))]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[active(U61(mark(_x0), _x1, _x2))]] [[mark(U62(_x0, _x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[active(U62(mark(_x0), _x1))]] [[mark(isNat(_x0))]] = x0 >= x0 = [[active(isNat(_x0))]] [[mark(s(_x0))]] = x0 >= x0 = [[active(s(mark(_x0)))]] [[mark(length(_x0))]] = 2x0 >= 2x0 = [[active(length(mark(_x0)))]] [[mark(nil)]] = 1 >= 1 = [[active(nil)]] [[cons(mark(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(_x0, mark(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(active(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(_x0, active(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[cons(_x0, _x1)]] [[U11(mark(_x0))]] = x0 >= x0 = [[U11(_x0)]] [[U11(active(_x0))]] = x0 >= x0 = [[U11(_x0)]] [[U21(mark(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U21(active(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U31(mark(_x0))]] = x0 >= x0 = [[U31(_x0)]] [[U31(active(_x0))]] = x0 >= x0 = [[U31(_x0)]] [[U41(mark(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[U42(active(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = 2x0 >= 2x0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = 2x0 >= 2x0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = x0 + x1 >= x0 + x1 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = x0 + x1 >= x0 + x1 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = x0 + x1 >= x0 + x1 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = x0 + x1 >= x0 + x1 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = x0 >= x0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = x0 >= x0 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = x0 >= x0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = x0 >= x0 = [[isNat(_x0)]] [[s(mark(_x0))]] = x0 >= x0 = [[s(_x0)]] [[s(active(_x0))]] = x0 >= x0 = [[s(_x0)]] [[length(mark(_x0))]] = 2x0 >= 2x0 = [[length(_x0)]] [[length(active(_x0))]] = 2x0 >= 2x0 = [[length(_x0)]] We can thus remove the following rules: active(isNatList(nil)) => mark(tt) active(length(nil)) => mark(0) We use rule removal, following [Kop12, Theorem 2.23]. This gives the following requirements (possibly using Theorems 2.25 and 2.26 in [Kop12]): active(zeros) >? mark(cons(0, zeros)) active(U11(tt)) >? mark(tt) active(U21(tt)) >? mark(tt) active(U31(tt)) >? mark(tt) active(U41(tt, X)) >? mark(U42(isNatIList(X))) active(U42(tt)) >? mark(tt) active(U51(tt, X)) >? mark(U52(isNatList(X))) active(U52(tt)) >? mark(tt) active(U61(tt, X, Y)) >? mark(U62(isNat(Y), X)) active(U62(tt, X)) >? mark(s(length(X))) active(isNat(0)) >? mark(tt) active(isNat(length(X))) >? mark(U11(isNatList(X))) active(isNat(s(X))) >? mark(U21(isNat(X))) active(isNatIList(X)) >? mark(U31(isNatList(X))) active(isNatIList(zeros)) >? mark(tt) active(isNatIList(cons(X, Y))) >? mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >? mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >? mark(U61(isNatList(Y), Y, X)) mark(zeros) >? active(zeros) mark(cons(X, Y)) >? active(cons(mark(X), Y)) mark(0) >? active(0) mark(U11(X)) >? active(U11(mark(X))) mark(tt) >? active(tt) mark(U21(X)) >? active(U21(mark(X))) mark(U31(X)) >? active(U31(mark(X))) mark(U41(X, Y)) >? active(U41(mark(X), Y)) mark(U42(X)) >? active(U42(mark(X))) mark(isNatIList(X)) >? active(isNatIList(X)) mark(U51(X, Y)) >? active(U51(mark(X), Y)) mark(U52(X)) >? active(U52(mark(X))) mark(isNatList(X)) >? active(isNatList(X)) mark(U61(X, Y, Z)) >? active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >? active(U62(mark(X), Y)) mark(isNat(X)) >? active(isNat(X)) mark(s(X)) >? active(s(mark(X))) mark(length(X)) >? active(length(mark(X))) mark(nil) >? active(nil) cons(mark(X), Y) >? cons(X, Y) cons(X, mark(Y)) >? cons(X, Y) cons(active(X), Y) >? cons(X, Y) cons(X, active(Y)) >? cons(X, Y) U11(mark(X)) >? U11(X) U11(active(X)) >? U11(X) U21(mark(X)) >? U21(X) U21(active(X)) >? U21(X) U31(mark(X)) >? U31(X) U31(active(X)) >? U31(X) U41(mark(X), Y) >? U41(X, Y) U41(X, mark(Y)) >? U41(X, Y) U41(active(X), Y) >? U41(X, Y) U41(X, active(Y)) >? U41(X, Y) U42(mark(X)) >? U42(X) U42(active(X)) >? U42(X) isNatIList(mark(X)) >? isNatIList(X) isNatIList(active(X)) >? isNatIList(X) U51(mark(X), Y) >? U51(X, Y) U51(X, mark(Y)) >? U51(X, Y) U51(active(X), Y) >? U51(X, Y) U51(X, active(Y)) >? U51(X, Y) U52(mark(X)) >? U52(X) U52(active(X)) >? U52(X) isNatList(mark(X)) >? isNatList(X) isNatList(active(X)) >? isNatList(X) U61(mark(X), Y, Z) >? U61(X, Y, Z) U61(X, mark(Y), Z) >? U61(X, Y, Z) U61(X, Y, mark(Z)) >? U61(X, Y, Z) U61(active(X), Y, Z) >? U61(X, Y, Z) U61(X, active(Y), Z) >? U61(X, Y, Z) U61(X, Y, active(Z)) >? U61(X, Y, Z) U62(mark(X), Y) >? U62(X, Y) U62(X, mark(Y)) >? U62(X, Y) U62(active(X), Y) >? U62(X, Y) U62(X, active(Y)) >? U62(X, Y) isNat(mark(X)) >? isNat(X) isNat(active(X)) >? isNat(X) s(mark(X)) >? s(X) s(active(X)) >? s(X) length(mark(X)) >? length(X) length(active(X)) >? length(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.2 + 2y0 U21 = \y0.y0 U31 = \y0.2y0 U41 = \y0y1.2y0 + 2y1 U42 = \y0.y0 U51 = \y0y1.y0 + y1 U52 = \y0.y0 U61 = \y0y1y2.2 + y2 + 2y0 + 2y1 U62 = \y0y1.2 + y0 + 2y1 active = \y0.y0 cons = \y0y1.2y0 + 2y1 isNat = \y0.y0 isNatIList = \y0.2y0 isNatList = \y0.y0 length = \y0.2 + 2y0 mark = \y0.y0 nil = 0 s = \y0.y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active(zeros)]] = 0 >= 0 = [[mark(cons(0, zeros))]] [[active(U11(tt))]] = 2 > 0 = [[mark(tt)]] [[active(U21(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U31(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U41(tt, _x0))]] = 2x0 >= 2x0 = [[mark(U42(isNatIList(_x0)))]] [[active(U42(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U51(tt, _x0))]] = x0 >= x0 = [[mark(U52(isNatList(_x0)))]] [[active(U52(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U61(tt, _x0, _x1))]] = 2 + x1 + 2x0 >= 2 + x1 + 2x0 = [[mark(U62(isNat(_x1), _x0))]] [[active(U62(tt, _x0))]] = 2 + 2x0 >= 2 + 2x0 = [[mark(s(length(_x0)))]] [[active(isNat(0))]] = 0 >= 0 = [[mark(tt)]] [[active(isNat(length(_x0)))]] = 2 + 2x0 >= 2 + 2x0 = [[mark(U11(isNatList(_x0)))]] [[active(isNat(s(_x0)))]] = x0 >= x0 = [[mark(U21(isNat(_x0)))]] [[active(isNatIList(_x0))]] = 2x0 >= 2x0 = [[mark(U31(isNatList(_x0)))]] [[active(isNatIList(zeros))]] = 0 >= 0 = [[mark(tt)]] [[active(isNatIList(cons(_x0, _x1)))]] = 4x0 + 4x1 >= 2x0 + 2x1 = [[mark(U41(isNat(_x0), _x1))]] [[active(isNatList(cons(_x0, _x1)))]] = 2x0 + 2x1 >= x0 + x1 = [[mark(U51(isNat(_x0), _x1))]] [[active(length(cons(_x0, _x1)))]] = 2 + 4x0 + 4x1 >= 2 + x0 + 4x1 = [[mark(U61(isNatList(_x1), _x1, _x0))]] [[mark(zeros)]] = 0 >= 0 = [[active(zeros)]] [[mark(cons(_x0, _x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[active(cons(mark(_x0), _x1))]] [[mark(0)]] = 0 >= 0 = [[active(0)]] [[mark(U11(_x0))]] = 2 + 2x0 >= 2 + 2x0 = [[active(U11(mark(_x0)))]] [[mark(tt)]] = 0 >= 0 = [[active(tt)]] [[mark(U21(_x0))]] = x0 >= x0 = [[active(U21(mark(_x0)))]] [[mark(U31(_x0))]] = 2x0 >= 2x0 = [[active(U31(mark(_x0)))]] [[mark(U41(_x0, _x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[active(U41(mark(_x0), _x1))]] [[mark(U42(_x0))]] = x0 >= x0 = [[active(U42(mark(_x0)))]] [[mark(isNatIList(_x0))]] = 2x0 >= 2x0 = [[active(isNatIList(_x0))]] [[mark(U51(_x0, _x1))]] = x0 + x1 >= x0 + x1 = [[active(U51(mark(_x0), _x1))]] [[mark(U52(_x0))]] = x0 >= x0 = [[active(U52(mark(_x0)))]] [[mark(isNatList(_x0))]] = x0 >= x0 = [[active(isNatList(_x0))]] [[mark(U61(_x0, _x1, _x2))]] = 2 + x2 + 2x0 + 2x1 >= 2 + x2 + 2x0 + 2x1 = [[active(U61(mark(_x0), _x1, _x2))]] [[mark(U62(_x0, _x1))]] = 2 + x0 + 2x1 >= 2 + x0 + 2x1 = [[active(U62(mark(_x0), _x1))]] [[mark(isNat(_x0))]] = x0 >= x0 = [[active(isNat(_x0))]] [[mark(s(_x0))]] = x0 >= x0 = [[active(s(mark(_x0)))]] [[mark(length(_x0))]] = 2 + 2x0 >= 2 + 2x0 = [[active(length(mark(_x0)))]] [[mark(nil)]] = 0 >= 0 = [[active(nil)]] [[cons(mark(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(_x0, mark(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(active(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(_x0, active(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[cons(_x0, _x1)]] [[U11(mark(_x0))]] = 2 + 2x0 >= 2 + 2x0 = [[U11(_x0)]] [[U11(active(_x0))]] = 2 + 2x0 >= 2 + 2x0 = [[U11(_x0)]] [[U21(mark(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U21(active(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U31(mark(_x0))]] = 2x0 >= 2x0 = [[U31(_x0)]] [[U31(active(_x0))]] = 2x0 >= 2x0 = [[U31(_x0)]] [[U41(mark(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[U42(active(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = 2x0 >= 2x0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = 2x0 >= 2x0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = x0 + x1 >= x0 + x1 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = x0 + x1 >= x0 + x1 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = x0 + x1 >= x0 + x1 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = x0 + x1 >= x0 + x1 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = x0 >= x0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = x0 >= x0 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = 2 + x2 + 2x0 + 2x1 >= 2 + x2 + 2x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = 2 + x2 + 2x0 + 2x1 >= 2 + x2 + 2x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = 2 + x2 + 2x0 + 2x1 >= 2 + x2 + 2x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = 2 + x2 + 2x0 + 2x1 >= 2 + x2 + 2x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = 2 + x2 + 2x0 + 2x1 >= 2 + x2 + 2x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = 2 + x2 + 2x0 + 2x1 >= 2 + x2 + 2x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = 2 + x0 + 2x1 >= 2 + x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = 2 + x0 + 2x1 >= 2 + x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = 2 + x0 + 2x1 >= 2 + x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = 2 + x0 + 2x1 >= 2 + x0 + 2x1 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = x0 >= x0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = x0 >= x0 = [[isNat(_x0)]] [[s(mark(_x0))]] = x0 >= x0 = [[s(_x0)]] [[s(active(_x0))]] = x0 >= x0 = [[s(_x0)]] [[length(mark(_x0))]] = 2 + 2x0 >= 2 + 2x0 = [[length(_x0)]] [[length(active(_x0))]] = 2 + 2x0 >= 2 + 2x0 = [[length(_x0)]] We can thus remove the following rules: active(U11(tt)) => mark(tt) We use rule removal, following [Kop12, Theorem 2.23]. This gives the following requirements (possibly using Theorems 2.25 and 2.26 in [Kop12]): active(zeros) >? mark(cons(0, zeros)) active(U21(tt)) >? mark(tt) active(U31(tt)) >? mark(tt) active(U41(tt, X)) >? mark(U42(isNatIList(X))) active(U42(tt)) >? mark(tt) active(U51(tt, X)) >? mark(U52(isNatList(X))) active(U52(tt)) >? mark(tt) active(U61(tt, X, Y)) >? mark(U62(isNat(Y), X)) active(U62(tt, X)) >? mark(s(length(X))) active(isNat(0)) >? mark(tt) active(isNat(length(X))) >? mark(U11(isNatList(X))) active(isNat(s(X))) >? mark(U21(isNat(X))) active(isNatIList(X)) >? mark(U31(isNatList(X))) active(isNatIList(zeros)) >? mark(tt) active(isNatIList(cons(X, Y))) >? mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >? mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >? mark(U61(isNatList(Y), Y, X)) mark(zeros) >? active(zeros) mark(cons(X, Y)) >? active(cons(mark(X), Y)) mark(0) >? active(0) mark(U11(X)) >? active(U11(mark(X))) mark(tt) >? active(tt) mark(U21(X)) >? active(U21(mark(X))) mark(U31(X)) >? active(U31(mark(X))) mark(U41(X, Y)) >? active(U41(mark(X), Y)) mark(U42(X)) >? active(U42(mark(X))) mark(isNatIList(X)) >? active(isNatIList(X)) mark(U51(X, Y)) >? active(U51(mark(X), Y)) mark(U52(X)) >? active(U52(mark(X))) mark(isNatList(X)) >? active(isNatList(X)) mark(U61(X, Y, Z)) >? active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >? active(U62(mark(X), Y)) mark(isNat(X)) >? active(isNat(X)) mark(s(X)) >? active(s(mark(X))) mark(length(X)) >? active(length(mark(X))) mark(nil) >? active(nil) cons(mark(X), Y) >? cons(X, Y) cons(X, mark(Y)) >? cons(X, Y) cons(active(X), Y) >? cons(X, Y) cons(X, active(Y)) >? cons(X, Y) U11(mark(X)) >? U11(X) U11(active(X)) >? U11(X) U21(mark(X)) >? U21(X) U21(active(X)) >? U21(X) U31(mark(X)) >? U31(X) U31(active(X)) >? U31(X) U41(mark(X), Y) >? U41(X, Y) U41(X, mark(Y)) >? U41(X, Y) U41(active(X), Y) >? U41(X, Y) U41(X, active(Y)) >? U41(X, Y) U42(mark(X)) >? U42(X) U42(active(X)) >? U42(X) isNatIList(mark(X)) >? isNatIList(X) isNatIList(active(X)) >? isNatIList(X) U51(mark(X), Y) >? U51(X, Y) U51(X, mark(Y)) >? U51(X, Y) U51(active(X), Y) >? U51(X, Y) U51(X, active(Y)) >? U51(X, Y) U52(mark(X)) >? U52(X) U52(active(X)) >? U52(X) isNatList(mark(X)) >? isNatList(X) isNatList(active(X)) >? isNatList(X) U61(mark(X), Y, Z) >? U61(X, Y, Z) U61(X, mark(Y), Z) >? U61(X, Y, Z) U61(X, Y, mark(Z)) >? U61(X, Y, Z) U61(active(X), Y, Z) >? U61(X, Y, Z) U61(X, active(Y), Z) >? U61(X, Y, Z) U61(X, Y, active(Z)) >? U61(X, Y, Z) U62(mark(X), Y) >? U62(X, Y) U62(X, mark(Y)) >? U62(X, Y) U62(active(X), Y) >? U62(X, Y) U62(X, active(Y)) >? U62(X, Y) isNat(mark(X)) >? isNat(X) isNat(active(X)) >? isNat(X) s(mark(X)) >? s(X) s(active(X)) >? s(X) length(mark(X)) >? length(X) length(active(X)) >? length(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.y0 U21 = \y0.y0 U31 = \y0.1 + y0 U41 = \y0y1.1 + y0 + 2y1 U42 = \y0.y0 U51 = \y0y1.y0 + 2y1 U52 = \y0.2y0 U61 = \y0y1y2.y0 + 2y1 + 2y2 U62 = \y0y1.2y0 + 2y1 active = \y0.y0 cons = \y0y1.2y0 + 2y1 isNat = \y0.y0 isNatIList = \y0.1 + 2y0 isNatList = \y0.y0 length = \y0.2y0 mark = \y0.y0 nil = 0 s = \y0.y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active(zeros)]] = 0 >= 0 = [[mark(cons(0, zeros))]] [[active(U21(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U31(tt))]] = 1 > 0 = [[mark(tt)]] [[active(U41(tt, _x0))]] = 1 + 2x0 >= 1 + 2x0 = [[mark(U42(isNatIList(_x0)))]] [[active(U42(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U51(tt, _x0))]] = 2x0 >= 2x0 = [[mark(U52(isNatList(_x0)))]] [[active(U52(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U61(tt, _x0, _x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[mark(U62(isNat(_x1), _x0))]] [[active(U62(tt, _x0))]] = 2x0 >= 2x0 = [[mark(s(length(_x0)))]] [[active(isNat(0))]] = 0 >= 0 = [[mark(tt)]] [[active(isNat(length(_x0)))]] = 2x0 >= x0 = [[mark(U11(isNatList(_x0)))]] [[active(isNat(s(_x0)))]] = x0 >= x0 = [[mark(U21(isNat(_x0)))]] [[active(isNatIList(_x0))]] = 1 + 2x0 >= 1 + x0 = [[mark(U31(isNatList(_x0)))]] [[active(isNatIList(zeros))]] = 1 > 0 = [[mark(tt)]] [[active(isNatIList(cons(_x0, _x1)))]] = 1 + 4x0 + 4x1 >= 1 + x0 + 2x1 = [[mark(U41(isNat(_x0), _x1))]] [[active(isNatList(cons(_x0, _x1)))]] = 2x0 + 2x1 >= x0 + 2x1 = [[mark(U51(isNat(_x0), _x1))]] [[active(length(cons(_x0, _x1)))]] = 4x0 + 4x1 >= 2x0 + 3x1 = [[mark(U61(isNatList(_x1), _x1, _x0))]] [[mark(zeros)]] = 0 >= 0 = [[active(zeros)]] [[mark(cons(_x0, _x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[active(cons(mark(_x0), _x1))]] [[mark(0)]] = 0 >= 0 = [[active(0)]] [[mark(U11(_x0))]] = x0 >= x0 = [[active(U11(mark(_x0)))]] [[mark(tt)]] = 0 >= 0 = [[active(tt)]] [[mark(U21(_x0))]] = x0 >= x0 = [[active(U21(mark(_x0)))]] [[mark(U31(_x0))]] = 1 + x0 >= 1 + x0 = [[active(U31(mark(_x0)))]] [[mark(U41(_x0, _x1))]] = 1 + x0 + 2x1 >= 1 + x0 + 2x1 = [[active(U41(mark(_x0), _x1))]] [[mark(U42(_x0))]] = x0 >= x0 = [[active(U42(mark(_x0)))]] [[mark(isNatIList(_x0))]] = 1 + 2x0 >= 1 + 2x0 = [[active(isNatIList(_x0))]] [[mark(U51(_x0, _x1))]] = x0 + 2x1 >= x0 + 2x1 = [[active(U51(mark(_x0), _x1))]] [[mark(U52(_x0))]] = 2x0 >= 2x0 = [[active(U52(mark(_x0)))]] [[mark(isNatList(_x0))]] = x0 >= x0 = [[active(isNatList(_x0))]] [[mark(U61(_x0, _x1, _x2))]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[active(U61(mark(_x0), _x1, _x2))]] [[mark(U62(_x0, _x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[active(U62(mark(_x0), _x1))]] [[mark(isNat(_x0))]] = x0 >= x0 = [[active(isNat(_x0))]] [[mark(s(_x0))]] = x0 >= x0 = [[active(s(mark(_x0)))]] [[mark(length(_x0))]] = 2x0 >= 2x0 = [[active(length(mark(_x0)))]] [[mark(nil)]] = 0 >= 0 = [[active(nil)]] [[cons(mark(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(_x0, mark(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(active(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(_x0, active(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[cons(_x0, _x1)]] [[U11(mark(_x0))]] = x0 >= x0 = [[U11(_x0)]] [[U11(active(_x0))]] = x0 >= x0 = [[U11(_x0)]] [[U21(mark(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U21(active(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U31(mark(_x0))]] = 1 + x0 >= 1 + x0 = [[U31(_x0)]] [[U31(active(_x0))]] = 1 + x0 >= 1 + x0 = [[U31(_x0)]] [[U41(mark(_x0), _x1)]] = 1 + x0 + 2x1 >= 1 + x0 + 2x1 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = 1 + x0 + 2x1 >= 1 + x0 + 2x1 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = 1 + x0 + 2x1 >= 1 + x0 + 2x1 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = 1 + x0 + 2x1 >= 1 + x0 + 2x1 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[U42(active(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = 1 + 2x0 >= 1 + 2x0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = 1 + 2x0 >= 1 + 2x0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = 2x0 >= 2x0 = [[U52(_x0)]] [[U52(active(_x0))]] = 2x0 >= 2x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = x0 >= x0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = x0 >= x0 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = x0 >= x0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = x0 >= x0 = [[isNat(_x0)]] [[s(mark(_x0))]] = x0 >= x0 = [[s(_x0)]] [[s(active(_x0))]] = x0 >= x0 = [[s(_x0)]] [[length(mark(_x0))]] = 2x0 >= 2x0 = [[length(_x0)]] [[length(active(_x0))]] = 2x0 >= 2x0 = [[length(_x0)]] We can thus remove the following rules: active(U31(tt)) => mark(tt) active(isNatIList(zeros)) => mark(tt) We use rule removal, following [Kop12, Theorem 2.23]. This gives the following requirements (possibly using Theorems 2.25 and 2.26 in [Kop12]): active(zeros) >? mark(cons(0, zeros)) active(U21(tt)) >? mark(tt) active(U41(tt, X)) >? mark(U42(isNatIList(X))) active(U42(tt)) >? mark(tt) active(U51(tt, X)) >? mark(U52(isNatList(X))) active(U52(tt)) >? mark(tt) active(U61(tt, X, Y)) >? mark(U62(isNat(Y), X)) active(U62(tt, X)) >? mark(s(length(X))) active(isNat(0)) >? mark(tt) active(isNat(length(X))) >? mark(U11(isNatList(X))) active(isNat(s(X))) >? mark(U21(isNat(X))) active(isNatIList(X)) >? mark(U31(isNatList(X))) active(isNatIList(cons(X, Y))) >? mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >? mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >? mark(U61(isNatList(Y), Y, X)) mark(zeros) >? active(zeros) mark(cons(X, Y)) >? active(cons(mark(X), Y)) mark(0) >? active(0) mark(U11(X)) >? active(U11(mark(X))) mark(tt) >? active(tt) mark(U21(X)) >? active(U21(mark(X))) mark(U31(X)) >? active(U31(mark(X))) mark(U41(X, Y)) >? active(U41(mark(X), Y)) mark(U42(X)) >? active(U42(mark(X))) mark(isNatIList(X)) >? active(isNatIList(X)) mark(U51(X, Y)) >? active(U51(mark(X), Y)) mark(U52(X)) >? active(U52(mark(X))) mark(isNatList(X)) >? active(isNatList(X)) mark(U61(X, Y, Z)) >? active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >? active(U62(mark(X), Y)) mark(isNat(X)) >? active(isNat(X)) mark(s(X)) >? active(s(mark(X))) mark(length(X)) >? active(length(mark(X))) mark(nil) >? active(nil) cons(mark(X), Y) >? cons(X, Y) cons(X, mark(Y)) >? cons(X, Y) cons(active(X), Y) >? cons(X, Y) cons(X, active(Y)) >? cons(X, Y) U11(mark(X)) >? U11(X) U11(active(X)) >? U11(X) U21(mark(X)) >? U21(X) U21(active(X)) >? U21(X) U31(mark(X)) >? U31(X) U31(active(X)) >? U31(X) U41(mark(X), Y) >? U41(X, Y) U41(X, mark(Y)) >? U41(X, Y) U41(active(X), Y) >? U41(X, Y) U41(X, active(Y)) >? U41(X, Y) U42(mark(X)) >? U42(X) U42(active(X)) >? U42(X) isNatIList(mark(X)) >? isNatIList(X) isNatIList(active(X)) >? isNatIList(X) U51(mark(X), Y) >? U51(X, Y) U51(X, mark(Y)) >? U51(X, Y) U51(active(X), Y) >? U51(X, Y) U51(X, active(Y)) >? U51(X, Y) U52(mark(X)) >? U52(X) U52(active(X)) >? U52(X) isNatList(mark(X)) >? isNatList(X) isNatList(active(X)) >? isNatList(X) U61(mark(X), Y, Z) >? U61(X, Y, Z) U61(X, mark(Y), Z) >? U61(X, Y, Z) U61(X, Y, mark(Z)) >? U61(X, Y, Z) U61(active(X), Y, Z) >? U61(X, Y, Z) U61(X, active(Y), Z) >? U61(X, Y, Z) U61(X, Y, active(Z)) >? U61(X, Y, Z) U62(mark(X), Y) >? U62(X, Y) U62(X, mark(Y)) >? U62(X, Y) U62(active(X), Y) >? U62(X, Y) U62(X, active(Y)) >? U62(X, Y) isNat(mark(X)) >? isNat(X) isNat(active(X)) >? isNat(X) s(mark(X)) >? s(X) s(active(X)) >? s(X) length(mark(X)) >? length(X) length(active(X)) >? length(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.y0 U21 = \y0.y0 U31 = \y0.y0 U41 = \y0y1.1 + y0 + y1 U42 = \y0.y0 U51 = \y0y1.y0 + y1 U52 = \y0.y0 U61 = \y0y1y2.y0 + 2y1 + 2y2 U62 = \y0y1.y0 + 2y1 active = \y0.y0 cons = \y0y1.2y0 + 3y1 isNat = \y0.2y0 isNatIList = \y0.1 + y0 isNatList = \y0.y0 length = \y0.y0 mark = \y0.y0 nil = 0 s = \y0.2y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active(zeros)]] = 0 >= 0 = [[mark(cons(0, zeros))]] [[active(U21(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U41(tt, _x0))]] = 1 + x0 >= 1 + x0 = [[mark(U42(isNatIList(_x0)))]] [[active(U42(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U51(tt, _x0))]] = x0 >= x0 = [[mark(U52(isNatList(_x0)))]] [[active(U52(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U61(tt, _x0, _x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[mark(U62(isNat(_x1), _x0))]] [[active(U62(tt, _x0))]] = 2x0 >= 2x0 = [[mark(s(length(_x0)))]] [[active(isNat(0))]] = 0 >= 0 = [[mark(tt)]] [[active(isNat(length(_x0)))]] = 2x0 >= x0 = [[mark(U11(isNatList(_x0)))]] [[active(isNat(s(_x0)))]] = 4x0 >= 2x0 = [[mark(U21(isNat(_x0)))]] [[active(isNatIList(_x0))]] = 1 + x0 > x0 = [[mark(U31(isNatList(_x0)))]] [[active(isNatIList(cons(_x0, _x1)))]] = 1 + 2x0 + 3x1 >= 1 + x1 + 2x0 = [[mark(U41(isNat(_x0), _x1))]] [[active(isNatList(cons(_x0, _x1)))]] = 2x0 + 3x1 >= x1 + 2x0 = [[mark(U51(isNat(_x0), _x1))]] [[active(length(cons(_x0, _x1)))]] = 2x0 + 3x1 >= 2x0 + 3x1 = [[mark(U61(isNatList(_x1), _x1, _x0))]] [[mark(zeros)]] = 0 >= 0 = [[active(zeros)]] [[mark(cons(_x0, _x1))]] = 2x0 + 3x1 >= 2x0 + 3x1 = [[active(cons(mark(_x0), _x1))]] [[mark(0)]] = 0 >= 0 = [[active(0)]] [[mark(U11(_x0))]] = x0 >= x0 = [[active(U11(mark(_x0)))]] [[mark(tt)]] = 0 >= 0 = [[active(tt)]] [[mark(U21(_x0))]] = x0 >= x0 = [[active(U21(mark(_x0)))]] [[mark(U31(_x0))]] = x0 >= x0 = [[active(U31(mark(_x0)))]] [[mark(U41(_x0, _x1))]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[active(U41(mark(_x0), _x1))]] [[mark(U42(_x0))]] = x0 >= x0 = [[active(U42(mark(_x0)))]] [[mark(isNatIList(_x0))]] = 1 + x0 >= 1 + x0 = [[active(isNatIList(_x0))]] [[mark(U51(_x0, _x1))]] = x0 + x1 >= x0 + x1 = [[active(U51(mark(_x0), _x1))]] [[mark(U52(_x0))]] = x0 >= x0 = [[active(U52(mark(_x0)))]] [[mark(isNatList(_x0))]] = x0 >= x0 = [[active(isNatList(_x0))]] [[mark(U61(_x0, _x1, _x2))]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[active(U61(mark(_x0), _x1, _x2))]] [[mark(U62(_x0, _x1))]] = x0 + 2x1 >= x0 + 2x1 = [[active(U62(mark(_x0), _x1))]] [[mark(isNat(_x0))]] = 2x0 >= 2x0 = [[active(isNat(_x0))]] [[mark(s(_x0))]] = 2x0 >= 2x0 = [[active(s(mark(_x0)))]] [[mark(length(_x0))]] = x0 >= x0 = [[active(length(mark(_x0)))]] [[mark(nil)]] = 0 >= 0 = [[active(nil)]] [[cons(mark(_x0), _x1)]] = 2x0 + 3x1 >= 2x0 + 3x1 = [[cons(_x0, _x1)]] [[cons(_x0, mark(_x1))]] = 2x0 + 3x1 >= 2x0 + 3x1 = [[cons(_x0, _x1)]] [[cons(active(_x0), _x1)]] = 2x0 + 3x1 >= 2x0 + 3x1 = [[cons(_x0, _x1)]] [[cons(_x0, active(_x1))]] = 2x0 + 3x1 >= 2x0 + 3x1 = [[cons(_x0, _x1)]] [[U11(mark(_x0))]] = x0 >= x0 = [[U11(_x0)]] [[U11(active(_x0))]] = x0 >= x0 = [[U11(_x0)]] [[U21(mark(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U21(active(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U31(mark(_x0))]] = x0 >= x0 = [[U31(_x0)]] [[U31(active(_x0))]] = x0 >= x0 = [[U31(_x0)]] [[U41(mark(_x0), _x1)]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[U42(active(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = 1 + x0 >= 1 + x0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = 1 + x0 >= 1 + x0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = x0 + x1 >= x0 + x1 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = x0 + x1 >= x0 + x1 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = x0 + x1 >= x0 + x1 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = x0 + x1 >= x0 + x1 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = x0 >= x0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = x0 >= x0 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = x0 + 2x1 + 2x2 >= x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = 2x0 >= 2x0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 2x0 >= 2x0 = [[isNat(_x0)]] [[s(mark(_x0))]] = 2x0 >= 2x0 = [[s(_x0)]] [[s(active(_x0))]] = 2x0 >= 2x0 = [[s(_x0)]] [[length(mark(_x0))]] = x0 >= x0 = [[length(_x0)]] [[length(active(_x0))]] = x0 >= x0 = [[length(_x0)]] We can thus remove the following rules: active(isNatIList(X)) => mark(U31(isNatList(X))) We use rule removal, following [Kop12, Theorem 2.23]. This gives the following requirements (possibly using Theorems 2.25 and 2.26 in [Kop12]): active(zeros) >? mark(cons(0, zeros)) active(U21(tt)) >? mark(tt) active(U41(tt, X)) >? mark(U42(isNatIList(X))) active(U42(tt)) >? mark(tt) active(U51(tt, X)) >? mark(U52(isNatList(X))) active(U52(tt)) >? mark(tt) active(U61(tt, X, Y)) >? mark(U62(isNat(Y), X)) active(U62(tt, X)) >? mark(s(length(X))) active(isNat(0)) >? mark(tt) active(isNat(length(X))) >? mark(U11(isNatList(X))) active(isNat(s(X))) >? mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >? mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >? mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >? mark(U61(isNatList(Y), Y, X)) mark(zeros) >? active(zeros) mark(cons(X, Y)) >? active(cons(mark(X), Y)) mark(0) >? active(0) mark(U11(X)) >? active(U11(mark(X))) mark(tt) >? active(tt) mark(U21(X)) >? active(U21(mark(X))) mark(U31(X)) >? active(U31(mark(X))) mark(U41(X, Y)) >? active(U41(mark(X), Y)) mark(U42(X)) >? active(U42(mark(X))) mark(isNatIList(X)) >? active(isNatIList(X)) mark(U51(X, Y)) >? active(U51(mark(X), Y)) mark(U52(X)) >? active(U52(mark(X))) mark(isNatList(X)) >? active(isNatList(X)) mark(U61(X, Y, Z)) >? active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >? active(U62(mark(X), Y)) mark(isNat(X)) >? active(isNat(X)) mark(s(X)) >? active(s(mark(X))) mark(length(X)) >? active(length(mark(X))) mark(nil) >? active(nil) cons(mark(X), Y) >? cons(X, Y) cons(X, mark(Y)) >? cons(X, Y) cons(active(X), Y) >? cons(X, Y) cons(X, active(Y)) >? cons(X, Y) U11(mark(X)) >? U11(X) U11(active(X)) >? U11(X) U21(mark(X)) >? U21(X) U21(active(X)) >? U21(X) U31(mark(X)) >? U31(X) U31(active(X)) >? U31(X) U41(mark(X), Y) >? U41(X, Y) U41(X, mark(Y)) >? U41(X, Y) U41(active(X), Y) >? U41(X, Y) U41(X, active(Y)) >? U41(X, Y) U42(mark(X)) >? U42(X) U42(active(X)) >? U42(X) isNatIList(mark(X)) >? isNatIList(X) isNatIList(active(X)) >? isNatIList(X) U51(mark(X), Y) >? U51(X, Y) U51(X, mark(Y)) >? U51(X, Y) U51(active(X), Y) >? U51(X, Y) U51(X, active(Y)) >? U51(X, Y) U52(mark(X)) >? U52(X) U52(active(X)) >? U52(X) isNatList(mark(X)) >? isNatList(X) isNatList(active(X)) >? isNatList(X) U61(mark(X), Y, Z) >? U61(X, Y, Z) U61(X, mark(Y), Z) >? U61(X, Y, Z) U61(X, Y, mark(Z)) >? U61(X, Y, Z) U61(active(X), Y, Z) >? U61(X, Y, Z) U61(X, active(Y), Z) >? U61(X, Y, Z) U61(X, Y, active(Z)) >? U61(X, Y, Z) U62(mark(X), Y) >? U62(X, Y) U62(X, mark(Y)) >? U62(X, Y) U62(active(X), Y) >? U62(X, Y) U62(X, active(Y)) >? U62(X, Y) isNat(mark(X)) >? isNat(X) isNat(active(X)) >? isNat(X) s(mark(X)) >? s(X) s(active(X)) >? s(X) length(mark(X)) >? length(X) length(active(X)) >? length(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.y0 U21 = \y0.y0 U31 = \y0.y0 U41 = \y0y1.2y0 + 2y1 U42 = \y0.2y0 U51 = \y0y1.y1 + 2y0 U52 = \y0.y0 U61 = \y0y1y2.1 + 2y0 + 2y1 + 2y2 U62 = \y0y1.1 + 2y0 + 2y1 active = \y0.y0 cons = \y0y1.2y0 + 2y1 isNat = \y0.y0 isNatIList = \y0.y0 isNatList = \y0.y0 length = \y0.1 + 2y0 mark = \y0.y0 nil = 0 s = \y0.y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active(zeros)]] = 0 >= 0 = [[mark(cons(0, zeros))]] [[active(U21(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U41(tt, _x0))]] = 2x0 >= 2x0 = [[mark(U42(isNatIList(_x0)))]] [[active(U42(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U51(tt, _x0))]] = x0 >= x0 = [[mark(U52(isNatList(_x0)))]] [[active(U52(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U61(tt, _x0, _x1))]] = 1 + 2x0 + 2x1 >= 1 + 2x0 + 2x1 = [[mark(U62(isNat(_x1), _x0))]] [[active(U62(tt, _x0))]] = 1 + 2x0 >= 1 + 2x0 = [[mark(s(length(_x0)))]] [[active(isNat(0))]] = 0 >= 0 = [[mark(tt)]] [[active(isNat(length(_x0)))]] = 1 + 2x0 > x0 = [[mark(U11(isNatList(_x0)))]] [[active(isNat(s(_x0)))]] = x0 >= x0 = [[mark(U21(isNat(_x0)))]] [[active(isNatIList(cons(_x0, _x1)))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[mark(U41(isNat(_x0), _x1))]] [[active(isNatList(cons(_x0, _x1)))]] = 2x0 + 2x1 >= x1 + 2x0 = [[mark(U51(isNat(_x0), _x1))]] [[active(length(cons(_x0, _x1)))]] = 1 + 4x0 + 4x1 >= 1 + 2x0 + 4x1 = [[mark(U61(isNatList(_x1), _x1, _x0))]] [[mark(zeros)]] = 0 >= 0 = [[active(zeros)]] [[mark(cons(_x0, _x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[active(cons(mark(_x0), _x1))]] [[mark(0)]] = 0 >= 0 = [[active(0)]] [[mark(U11(_x0))]] = x0 >= x0 = [[active(U11(mark(_x0)))]] [[mark(tt)]] = 0 >= 0 = [[active(tt)]] [[mark(U21(_x0))]] = x0 >= x0 = [[active(U21(mark(_x0)))]] [[mark(U31(_x0))]] = x0 >= x0 = [[active(U31(mark(_x0)))]] [[mark(U41(_x0, _x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[active(U41(mark(_x0), _x1))]] [[mark(U42(_x0))]] = 2x0 >= 2x0 = [[active(U42(mark(_x0)))]] [[mark(isNatIList(_x0))]] = x0 >= x0 = [[active(isNatIList(_x0))]] [[mark(U51(_x0, _x1))]] = x1 + 2x0 >= x1 + 2x0 = [[active(U51(mark(_x0), _x1))]] [[mark(U52(_x0))]] = x0 >= x0 = [[active(U52(mark(_x0)))]] [[mark(isNatList(_x0))]] = x0 >= x0 = [[active(isNatList(_x0))]] [[mark(U61(_x0, _x1, _x2))]] = 1 + 2x0 + 2x1 + 2x2 >= 1 + 2x0 + 2x1 + 2x2 = [[active(U61(mark(_x0), _x1, _x2))]] [[mark(U62(_x0, _x1))]] = 1 + 2x0 + 2x1 >= 1 + 2x0 + 2x1 = [[active(U62(mark(_x0), _x1))]] [[mark(isNat(_x0))]] = x0 >= x0 = [[active(isNat(_x0))]] [[mark(s(_x0))]] = x0 >= x0 = [[active(s(mark(_x0)))]] [[mark(length(_x0))]] = 1 + 2x0 >= 1 + 2x0 = [[active(length(mark(_x0)))]] [[mark(nil)]] = 0 >= 0 = [[active(nil)]] [[cons(mark(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(_x0, mark(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(active(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(_x0, active(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[cons(_x0, _x1)]] [[U11(mark(_x0))]] = x0 >= x0 = [[U11(_x0)]] [[U11(active(_x0))]] = x0 >= x0 = [[U11(_x0)]] [[U21(mark(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U21(active(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U31(mark(_x0))]] = x0 >= x0 = [[U31(_x0)]] [[U31(active(_x0))]] = x0 >= x0 = [[U31(_x0)]] [[U41(mark(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = 2x0 >= 2x0 = [[U42(_x0)]] [[U42(active(_x0))]] = 2x0 >= 2x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = x0 >= x0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = x0 >= x0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = x1 + 2x0 >= x1 + 2x0 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = x1 + 2x0 >= x1 + 2x0 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = x1 + 2x0 >= x1 + 2x0 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = x1 + 2x0 >= x1 + 2x0 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = x0 >= x0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = x0 >= x0 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = 1 + 2x0 + 2x1 + 2x2 >= 1 + 2x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = 1 + 2x0 + 2x1 + 2x2 >= 1 + 2x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = 1 + 2x0 + 2x1 + 2x2 >= 1 + 2x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = 1 + 2x0 + 2x1 + 2x2 >= 1 + 2x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = 1 + 2x0 + 2x1 + 2x2 >= 1 + 2x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = 1 + 2x0 + 2x1 + 2x2 >= 1 + 2x0 + 2x1 + 2x2 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = 1 + 2x0 + 2x1 >= 1 + 2x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = 1 + 2x0 + 2x1 >= 1 + 2x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = 1 + 2x0 + 2x1 >= 1 + 2x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = 1 + 2x0 + 2x1 >= 1 + 2x0 + 2x1 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = x0 >= x0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = x0 >= x0 = [[isNat(_x0)]] [[s(mark(_x0))]] = x0 >= x0 = [[s(_x0)]] [[s(active(_x0))]] = x0 >= x0 = [[s(_x0)]] [[length(mark(_x0))]] = 1 + 2x0 >= 1 + 2x0 = [[length(_x0)]] [[length(active(_x0))]] = 1 + 2x0 >= 1 + 2x0 = [[length(_x0)]] We can thus remove the following rules: active(isNat(length(X))) => mark(U11(isNatList(X))) We use the dependency pair framework as described in [Kop12, Ch. 6/7], with static dependency pairs (see [KusIsoSakBla09] and the adaptation for AFSMs in [Kop12, Ch. 7.8]). We thus obtain the following dependency pair problem (P_0, R_0, minimal, formative): Dependency Pairs P_0: 0] active#(zeros) =#> mark#(cons(0, zeros)) 1] active#(zeros) =#> cons#(0, zeros) 2] active#(U21(tt)) =#> mark#(tt) 3] active#(U41(tt, X)) =#> mark#(U42(isNatIList(X))) 4] active#(U41(tt, X)) =#> U42#(isNatIList(X)) 5] active#(U41(tt, X)) =#> isNatIList#(X) 6] active#(U42(tt)) =#> mark#(tt) 7] active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) 8] active#(U51(tt, X)) =#> U52#(isNatList(X)) 9] active#(U51(tt, X)) =#> isNatList#(X) 10] active#(U52(tt)) =#> mark#(tt) 11] active#(U61(tt, X, Y)) =#> mark#(U62(isNat(Y), X)) 12] active#(U61(tt, X, Y)) =#> U62#(isNat(Y), X) 13] active#(U61(tt, X, Y)) =#> isNat#(Y) 14] active#(U62(tt, X)) =#> mark#(s(length(X))) 15] active#(U62(tt, X)) =#> s#(length(X)) 16] active#(U62(tt, X)) =#> length#(X) 17] active#(isNat(0)) =#> mark#(tt) 18] active#(isNat(s(X))) =#> mark#(U21(isNat(X))) 19] active#(isNat(s(X))) =#> U21#(isNat(X)) 20] active#(isNat(s(X))) =#> isNat#(X) 21] active#(isNatIList(cons(X, Y))) =#> mark#(U41(isNat(X), Y)) 22] active#(isNatIList(cons(X, Y))) =#> U41#(isNat(X), Y) 23] active#(isNatIList(cons(X, Y))) =#> isNat#(X) 24] active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) 25] active#(isNatList(cons(X, Y))) =#> U51#(isNat(X), Y) 26] active#(isNatList(cons(X, Y))) =#> isNat#(X) 27] active#(length(cons(X, Y))) =#> mark#(U61(isNatList(Y), Y, X)) 28] active#(length(cons(X, Y))) =#> U61#(isNatList(Y), Y, X) 29] active#(length(cons(X, Y))) =#> isNatList#(Y) 30] mark#(zeros) =#> active#(zeros) 31] mark#(cons(X, Y)) =#> active#(cons(mark(X), Y)) 32] mark#(cons(X, Y)) =#> cons#(mark(X), Y) 33] mark#(cons(X, Y)) =#> mark#(X) 34] mark#(0) =#> active#(0) 35] mark#(U11(X)) =#> active#(U11(mark(X))) 36] mark#(U11(X)) =#> U11#(mark(X)) 37] mark#(U11(X)) =#> mark#(X) 38] mark#(tt) =#> active#(tt) 39] mark#(U21(X)) =#> active#(U21(mark(X))) 40] mark#(U21(X)) =#> U21#(mark(X)) 41] mark#(U21(X)) =#> mark#(X) 42] mark#(U31(X)) =#> active#(U31(mark(X))) 43] mark#(U31(X)) =#> U31#(mark(X)) 44] mark#(U31(X)) =#> mark#(X) 45] mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) 46] mark#(U41(X, Y)) =#> U41#(mark(X), Y) 47] mark#(U41(X, Y)) =#> mark#(X) 48] mark#(U42(X)) =#> active#(U42(mark(X))) 49] mark#(U42(X)) =#> U42#(mark(X)) 50] mark#(U42(X)) =#> mark#(X) 51] mark#(isNatIList(X)) =#> active#(isNatIList(X)) 52] mark#(isNatIList(X)) =#> isNatIList#(X) 53] mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) 54] mark#(U51(X, Y)) =#> U51#(mark(X), Y) 55] mark#(U51(X, Y)) =#> mark#(X) 56] mark#(U52(X)) =#> active#(U52(mark(X))) 57] mark#(U52(X)) =#> U52#(mark(X)) 58] mark#(U52(X)) =#> mark#(X) 59] mark#(isNatList(X)) =#> active#(isNatList(X)) 60] mark#(isNatList(X)) =#> isNatList#(X) 61] mark#(U61(X, Y, Z)) =#> active#(U61(mark(X), Y, Z)) 62] mark#(U61(X, Y, Z)) =#> U61#(mark(X), Y, Z) 63] mark#(U61(X, Y, Z)) =#> mark#(X) 64] mark#(U62(X, Y)) =#> active#(U62(mark(X), Y)) 65] mark#(U62(X, Y)) =#> U62#(mark(X), Y) 66] mark#(U62(X, Y)) =#> mark#(X) 67] mark#(isNat(X)) =#> active#(isNat(X)) 68] mark#(isNat(X)) =#> isNat#(X) 69] mark#(s(X)) =#> active#(s(mark(X))) 70] mark#(s(X)) =#> s#(mark(X)) 71] mark#(s(X)) =#> mark#(X) 72] mark#(length(X)) =#> active#(length(mark(X))) 73] mark#(length(X)) =#> length#(mark(X)) 74] mark#(length(X)) =#> mark#(X) 75] mark#(nil) =#> active#(nil) 76] cons#(mark(X), Y) =#> cons#(X, Y) 77] cons#(X, mark(Y)) =#> cons#(X, Y) 78] cons#(active(X), Y) =#> cons#(X, Y) 79] cons#(X, active(Y)) =#> cons#(X, Y) 80] U11#(mark(X)) =#> U11#(X) 81] U11#(active(X)) =#> U11#(X) 82] U21#(mark(X)) =#> U21#(X) 83] U21#(active(X)) =#> U21#(X) 84] U31#(mark(X)) =#> U31#(X) 85] U31#(active(X)) =#> U31#(X) 86] U41#(mark(X), Y) =#> U41#(X, Y) 87] U41#(X, mark(Y)) =#> U41#(X, Y) 88] U41#(active(X), Y) =#> U41#(X, Y) 89] U41#(X, active(Y)) =#> U41#(X, Y) 90] U42#(mark(X)) =#> U42#(X) 91] U42#(active(X)) =#> U42#(X) 92] isNatIList#(mark(X)) =#> isNatIList#(X) 93] isNatIList#(active(X)) =#> isNatIList#(X) 94] U51#(mark(X), Y) =#> U51#(X, Y) 95] U51#(X, mark(Y)) =#> U51#(X, Y) 96] U51#(active(X), Y) =#> U51#(X, Y) 97] U51#(X, active(Y)) =#> U51#(X, Y) 98] U52#(mark(X)) =#> U52#(X) 99] U52#(active(X)) =#> U52#(X) 100] isNatList#(mark(X)) =#> isNatList#(X) 101] isNatList#(active(X)) =#> isNatList#(X) 102] U61#(mark(X), Y, Z) =#> U61#(X, Y, Z) 103] U61#(X, mark(Y), Z) =#> U61#(X, Y, Z) 104] U61#(X, Y, mark(Z)) =#> U61#(X, Y, Z) 105] U61#(active(X), Y, Z) =#> U61#(X, Y, Z) 106] U61#(X, active(Y), Z) =#> U61#(X, Y, Z) 107] U61#(X, Y, active(Z)) =#> U61#(X, Y, Z) 108] U62#(mark(X), Y) =#> U62#(X, Y) 109] U62#(X, mark(Y)) =#> U62#(X, Y) 110] U62#(active(X), Y) =#> U62#(X, Y) 111] U62#(X, active(Y)) =#> U62#(X, Y) 112] isNat#(mark(X)) =#> isNat#(X) 113] isNat#(active(X)) =#> isNat#(X) 114] s#(mark(X)) =#> s#(X) 115] s#(active(X)) =#> s#(X) 116] length#(mark(X)) =#> length#(X) 117] length#(active(X)) =#> length#(X) Rules R_0: active(zeros) => mark(cons(0, zeros)) active(U21(tt)) => mark(tt) active(U41(tt, X)) => mark(U42(isNatIList(X))) active(U42(tt)) => mark(tt) active(U51(tt, X)) => mark(U52(isNatList(X))) active(U52(tt)) => mark(tt) active(U61(tt, X, Y)) => mark(U62(isNat(Y), X)) active(U62(tt, X)) => mark(s(length(X))) active(isNat(0)) => mark(tt) active(isNat(s(X))) => mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) => mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) => mark(U51(isNat(X), Y)) active(length(cons(X, Y))) => mark(U61(isNatList(Y), Y, X)) mark(zeros) => active(zeros) mark(cons(X, Y)) => active(cons(mark(X), Y)) mark(0) => active(0) mark(U11(X)) => active(U11(mark(X))) mark(tt) => active(tt) mark(U21(X)) => active(U21(mark(X))) mark(U31(X)) => active(U31(mark(X))) mark(U41(X, Y)) => active(U41(mark(X), Y)) mark(U42(X)) => active(U42(mark(X))) mark(isNatIList(X)) => active(isNatIList(X)) mark(U51(X, Y)) => active(U51(mark(X), Y)) mark(U52(X)) => active(U52(mark(X))) mark(isNatList(X)) => active(isNatList(X)) mark(U61(X, Y, Z)) => active(U61(mark(X), Y, Z)) mark(U62(X, Y)) => active(U62(mark(X), Y)) mark(isNat(X)) => active(isNat(X)) mark(s(X)) => active(s(mark(X))) mark(length(X)) => active(length(mark(X))) mark(nil) => active(nil) cons(mark(X), Y) => cons(X, Y) cons(X, mark(Y)) => cons(X, Y) cons(active(X), Y) => cons(X, Y) cons(X, active(Y)) => cons(X, Y) U11(mark(X)) => U11(X) U11(active(X)) => U11(X) U21(mark(X)) => U21(X) U21(active(X)) => U21(X) U31(mark(X)) => U31(X) U31(active(X)) => U31(X) U41(mark(X), Y) => U41(X, Y) U41(X, mark(Y)) => U41(X, Y) U41(active(X), Y) => U41(X, Y) U41(X, active(Y)) => U41(X, Y) U42(mark(X)) => U42(X) U42(active(X)) => U42(X) isNatIList(mark(X)) => isNatIList(X) isNatIList(active(X)) => isNatIList(X) U51(mark(X), Y) => U51(X, Y) U51(X, mark(Y)) => U51(X, Y) U51(active(X), Y) => U51(X, Y) U51(X, active(Y)) => U51(X, Y) U52(mark(X)) => U52(X) U52(active(X)) => U52(X) isNatList(mark(X)) => isNatList(X) isNatList(active(X)) => isNatList(X) U61(mark(X), Y, Z) => U61(X, Y, Z) U61(X, mark(Y), Z) => U61(X, Y, Z) U61(X, Y, mark(Z)) => U61(X, Y, Z) U61(active(X), Y, Z) => U61(X, Y, Z) U61(X, active(Y), Z) => U61(X, Y, Z) U61(X, Y, active(Z)) => U61(X, Y, Z) U62(mark(X), Y) => U62(X, Y) U62(X, mark(Y)) => U62(X, Y) U62(active(X), Y) => U62(X, Y) U62(X, active(Y)) => U62(X, Y) isNat(mark(X)) => isNat(X) isNat(active(X)) => isNat(X) s(mark(X)) => s(X) s(active(X)) => s(X) length(mark(X)) => length(X) length(active(X)) => length(X) Thus, the original system is terminating if (P_0, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_0, R_0, minimal, formative). We place the elements of P in a dependency graph approximation G (see e.g. [Kop12, Thm. 7.27, 7.29], as follows: * 0 : 31, 32, 33 * 1 : * 2 : 38 * 3 : 48, 49, 50 * 4 : * 5 : 92, 93 * 6 : 38 * 7 : 56, 57, 58 * 8 : * 9 : 100, 101 * 10 : 38 * 11 : 64, 65, 66 * 12 : 109, 111 * 13 : 112, 113 * 14 : 69, 70, 71 * 15 : * 16 : 116, 117 * 17 : 38 * 18 : 39, 40, 41 * 19 : * 20 : 112, 113 * 21 : 45, 46, 47 * 22 : 87, 89 * 23 : 112, 113 * 24 : 53, 54, 55 * 25 : 95, 97 * 26 : 112, 113 * 27 : 61, 62, 63 * 28 : 103, 104, 106, 107 * 29 : 100, 101 * 30 : 0, 1 * 31 : * 32 : 76, 77, 78, 79 * 33 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 * 34 : * 35 : * 36 : 80, 81 * 37 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 * 38 : * 39 : 2 * 40 : 82, 83 * 41 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 * 42 : * 43 : 84, 85 * 44 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 * 45 : 3, 4, 5 * 46 : 86, 87, 88, 89 * 47 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 * 48 : 6 * 49 : 90, 91 * 50 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 * 51 : 21, 22, 23 * 52 : 92, 93 * 53 : 7, 8, 9 * 54 : 94, 95, 96, 97 * 55 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 * 56 : 10 * 57 : 98, 99 * 58 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 * 59 : 24, 25, 26 * 60 : 100, 101 * 61 : 11, 12, 13 * 62 : 102, 103, 104, 105, 106, 107 * 63 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 * 64 : 14, 15, 16 * 65 : 108, 109, 110, 111 * 66 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 * 67 : 17, 18, 19, 20 * 68 : 112, 113 * 69 : * 70 : 114, 115 * 71 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 * 72 : 27, 28, 29 * 73 : 116, 117 * 74 : 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75 * 75 : * 76 : 76, 77, 78, 79 * 77 : 76, 77, 78, 79 * 78 : 76, 77, 78, 79 * 79 : 76, 77, 78, 79 * 80 : 80, 81 * 81 : 80, 81 * 82 : 82, 83 * 83 : 82, 83 * 84 : 84, 85 * 85 : 84, 85 * 86 : 86, 87, 88, 89 * 87 : 86, 87, 88, 89 * 88 : 86, 87, 88, 89 * 89 : 86, 87, 88, 89 * 90 : 90, 91 * 91 : 90, 91 * 92 : 92, 93 * 93 : 92, 93 * 94 : 94, 95, 96, 97 * 95 : 94, 95, 96, 97 * 96 : 94, 95, 96, 97 * 97 : 94, 95, 96, 97 * 98 : 98, 99 * 99 : 98, 99 * 100 : 100, 101 * 101 : 100, 101 * 102 : 102, 103, 104, 105, 106, 107 * 103 : 102, 103, 104, 105, 106, 107 * 104 : 102, 103, 104, 105, 106, 107 * 105 : 102, 103, 104, 105, 106, 107 * 106 : 102, 103, 104, 105, 106, 107 * 107 : 102, 103, 104, 105, 106, 107 * 108 : 108, 109, 110, 111 * 109 : 108, 109, 110, 111 * 110 : 108, 109, 110, 111 * 111 : 108, 109, 110, 111 * 112 : 112, 113 * 113 : 112, 113 * 114 : 114, 115 * 115 : 114, 115 * 116 : 116, 117 * 117 : 116, 117 This graph has the following strongly connected components: P_1: active#(zeros) =#> mark#(cons(0, zeros)) active#(U41(tt, X)) =#> mark#(U42(isNatIList(X))) active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) =#> mark#(U62(isNat(Y), X)) active#(U62(tt, X)) =#> mark#(s(length(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) =#> mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) =#> mark#(U61(isNatList(Y), Y, X)) mark#(zeros) =#> active#(zeros) mark#(cons(X, Y)) =#> mark#(X) mark#(U11(X)) =#> mark#(X) mark#(U21(X)) =#> mark#(X) mark#(U31(X)) =#> mark#(X) mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) mark#(U41(X, Y)) =#> mark#(X) mark#(U42(X)) =#> mark#(X) mark#(isNatIList(X)) =#> active#(isNatIList(X)) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U51(X, Y)) =#> mark#(X) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(U61(X, Y, Z)) =#> active#(U61(mark(X), Y, Z)) mark#(U61(X, Y, Z)) =#> mark#(X) mark#(U62(X, Y)) =#> active#(U62(mark(X), Y)) mark#(U62(X, Y)) =#> mark#(X) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) mark#(length(X)) =#> active#(length(mark(X))) mark#(length(X)) =#> mark#(X) P_2: cons#(mark(X), Y) =#> cons#(X, Y) cons#(X, mark(Y)) =#> cons#(X, Y) cons#(active(X), Y) =#> cons#(X, Y) cons#(X, active(Y)) =#> cons#(X, Y) P_3: U11#(mark(X)) =#> U11#(X) U11#(active(X)) =#> U11#(X) P_4: U21#(mark(X)) =#> U21#(X) U21#(active(X)) =#> U21#(X) P_5: U31#(mark(X)) =#> U31#(X) U31#(active(X)) =#> U31#(X) P_6: U41#(mark(X), Y) =#> U41#(X, Y) U41#(X, mark(Y)) =#> U41#(X, Y) U41#(active(X), Y) =#> U41#(X, Y) U41#(X, active(Y)) =#> U41#(X, Y) P_7: U42#(mark(X)) =#> U42#(X) U42#(active(X)) =#> U42#(X) P_8: isNatIList#(mark(X)) =#> isNatIList#(X) isNatIList#(active(X)) =#> isNatIList#(X) P_9: U51#(mark(X), Y) =#> U51#(X, Y) U51#(X, mark(Y)) =#> U51#(X, Y) U51#(active(X), Y) =#> U51#(X, Y) U51#(X, active(Y)) =#> U51#(X, Y) P_10: U52#(mark(X)) =#> U52#(X) U52#(active(X)) =#> U52#(X) P_11: isNatList#(mark(X)) =#> isNatList#(X) isNatList#(active(X)) =#> isNatList#(X) P_12: U61#(mark(X), Y, Z) =#> U61#(X, Y, Z) U61#(X, mark(Y), Z) =#> U61#(X, Y, Z) U61#(X, Y, mark(Z)) =#> U61#(X, Y, Z) U61#(active(X), Y, Z) =#> U61#(X, Y, Z) U61#(X, active(Y), Z) =#> U61#(X, Y, Z) U61#(X, Y, active(Z)) =#> U61#(X, Y, Z) P_13: U62#(mark(X), Y) =#> U62#(X, Y) U62#(X, mark(Y)) =#> U62#(X, Y) U62#(active(X), Y) =#> U62#(X, Y) U62#(X, active(Y)) =#> U62#(X, Y) P_14: isNat#(mark(X)) =#> isNat#(X) isNat#(active(X)) =#> isNat#(X) P_15: s#(mark(X)) =#> s#(X) s#(active(X)) =#> s#(X) P_16: length#(mark(X)) =#> length#(X) length#(active(X)) =#> length#(X) By [Kop12, Thm. 7.31], we may replace any dependency pair problem (P_0, R_0, m, f) by (P_1, R_0, m, f), (P_2, R_0, m, f), (P_3, R_0, m, f), (P_4, R_0, m, f), (P_5, R_0, m, f), (P_6, R_0, m, f), (P_7, R_0, m, f), (P_8, R_0, m, f), (P_9, R_0, m, f), (P_10, R_0, m, f), (P_11, R_0, m, f), (P_12, R_0, m, f), (P_13, R_0, m, f), (P_14, R_0, m, f), (P_15, R_0, m, f) and (P_16, R_0, m, f). Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative), (P_8, R_0, minimal, formative), (P_9, R_0, minimal, formative), (P_10, R_0, minimal, formative), (P_11, R_0, minimal, formative), (P_12, R_0, minimal, formative), (P_13, R_0, minimal, formative), (P_14, R_0, minimal, formative), (P_15, R_0, minimal, formative) and (P_16, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_16, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(length#) = 1 Thus, we can orient the dependency pairs as follows: nu(length#(mark(X))) = mark(X) |> X = nu(length#(X)) nu(length#(active(X))) = active(X) |> X = nu(length#(X)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_16, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative), (P_8, R_0, minimal, formative), (P_9, R_0, minimal, formative), (P_10, R_0, minimal, formative), (P_11, R_0, minimal, formative), (P_12, R_0, minimal, formative), (P_13, R_0, minimal, formative), (P_14, R_0, minimal, formative) and (P_15, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_15, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(s#) = 1 Thus, we can orient the dependency pairs as follows: nu(s#(mark(X))) = mark(X) |> X = nu(s#(X)) nu(s#(active(X))) = active(X) |> X = nu(s#(X)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_15, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative), (P_8, R_0, minimal, formative), (P_9, R_0, minimal, formative), (P_10, R_0, minimal, formative), (P_11, R_0, minimal, formative), (P_12, R_0, minimal, formative), (P_13, R_0, minimal, formative) and (P_14, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_14, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(isNat#) = 1 Thus, we can orient the dependency pairs as follows: nu(isNat#(mark(X))) = mark(X) |> X = nu(isNat#(X)) nu(isNat#(active(X))) = active(X) |> X = nu(isNat#(X)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_14, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative), (P_8, R_0, minimal, formative), (P_9, R_0, minimal, formative), (P_10, R_0, minimal, formative), (P_11, R_0, minimal, formative), (P_12, R_0, minimal, formative) and (P_13, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_13, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U62#) = 1 Thus, we can orient the dependency pairs as follows: nu(U62#(mark(X), Y)) = mark(X) |> X = nu(U62#(X, Y)) nu(U62#(X, mark(Y))) = X = X = nu(U62#(X, Y)) nu(U62#(active(X), Y)) = active(X) |> X = nu(U62#(X, Y)) nu(U62#(X, active(Y))) = X = X = nu(U62#(X, Y)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_13, R_0, minimal, f) by (P_17, R_0, minimal, f), where P_17 contains: U62#(X, mark(Y)) =#> U62#(X, Y) U62#(X, active(Y)) =#> U62#(X, Y) Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative), (P_8, R_0, minimal, formative), (P_9, R_0, minimal, formative), (P_10, R_0, minimal, formative), (P_11, R_0, minimal, formative), (P_12, R_0, minimal, formative) and (P_17, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_17, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U62#) = 2 Thus, we can orient the dependency pairs as follows: nu(U62#(X, mark(Y))) = mark(Y) |> Y = nu(U62#(X, Y)) nu(U62#(X, active(Y))) = active(Y) |> Y = nu(U62#(X, Y)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_17, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative), (P_8, R_0, minimal, formative), (P_9, R_0, minimal, formative), (P_10, R_0, minimal, formative), (P_11, R_0, minimal, formative) and (P_12, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_12, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U61#) = 1 Thus, we can orient the dependency pairs as follows: nu(U61#(mark(X), Y, Z)) = mark(X) |> X = nu(U61#(X, Y, Z)) nu(U61#(X, mark(Y), Z)) = X = X = nu(U61#(X, Y, Z)) nu(U61#(X, Y, mark(Z))) = X = X = nu(U61#(X, Y, Z)) nu(U61#(active(X), Y, Z)) = active(X) |> X = nu(U61#(X, Y, Z)) nu(U61#(X, active(Y), Z)) = X = X = nu(U61#(X, Y, Z)) nu(U61#(X, Y, active(Z))) = X = X = nu(U61#(X, Y, Z)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_12, R_0, minimal, f) by (P_18, R_0, minimal, f), where P_18 contains: U61#(X, mark(Y), Z) =#> U61#(X, Y, Z) U61#(X, Y, mark(Z)) =#> U61#(X, Y, Z) U61#(X, active(Y), Z) =#> U61#(X, Y, Z) U61#(X, Y, active(Z)) =#> U61#(X, Y, Z) Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative), (P_8, R_0, minimal, formative), (P_9, R_0, minimal, formative), (P_10, R_0, minimal, formative), (P_11, R_0, minimal, formative) and (P_18, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_18, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U61#) = 2 Thus, we can orient the dependency pairs as follows: nu(U61#(X, mark(Y), Z)) = mark(Y) |> Y = nu(U61#(X, Y, Z)) nu(U61#(X, Y, mark(Z))) = Y = Y = nu(U61#(X, Y, Z)) nu(U61#(X, active(Y), Z)) = active(Y) |> Y = nu(U61#(X, Y, Z)) nu(U61#(X, Y, active(Z))) = Y = Y = nu(U61#(X, Y, Z)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_18, R_0, minimal, f) by (P_19, R_0, minimal, f), where P_19 contains: U61#(X, Y, mark(Z)) =#> U61#(X, Y, Z) U61#(X, Y, active(Z)) =#> U61#(X, Y, Z) Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative), (P_8, R_0, minimal, formative), (P_9, R_0, minimal, formative), (P_10, R_0, minimal, formative), (P_11, R_0, minimal, formative) and (P_19, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_19, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U61#) = 3 Thus, we can orient the dependency pairs as follows: nu(U61#(X, Y, mark(Z))) = mark(Z) |> Z = nu(U61#(X, Y, Z)) nu(U61#(X, Y, active(Z))) = active(Z) |> Z = nu(U61#(X, Y, Z)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_19, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative), (P_8, R_0, minimal, formative), (P_9, R_0, minimal, formative), (P_10, R_0, minimal, formative) and (P_11, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_11, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(isNatList#) = 1 Thus, we can orient the dependency pairs as follows: nu(isNatList#(mark(X))) = mark(X) |> X = nu(isNatList#(X)) nu(isNatList#(active(X))) = active(X) |> X = nu(isNatList#(X)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_11, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative), (P_8, R_0, minimal, formative), (P_9, R_0, minimal, formative) and (P_10, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_10, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U52#) = 1 Thus, we can orient the dependency pairs as follows: nu(U52#(mark(X))) = mark(X) |> X = nu(U52#(X)) nu(U52#(active(X))) = active(X) |> X = nu(U52#(X)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_10, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative), (P_8, R_0, minimal, formative) and (P_9, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_9, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U51#) = 1 Thus, we can orient the dependency pairs as follows: nu(U51#(mark(X), Y)) = mark(X) |> X = nu(U51#(X, Y)) nu(U51#(X, mark(Y))) = X = X = nu(U51#(X, Y)) nu(U51#(active(X), Y)) = active(X) |> X = nu(U51#(X, Y)) nu(U51#(X, active(Y))) = X = X = nu(U51#(X, Y)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_9, R_0, minimal, f) by (P_20, R_0, minimal, f), where P_20 contains: U51#(X, mark(Y)) =#> U51#(X, Y) U51#(X, active(Y)) =#> U51#(X, Y) Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative), (P_8, R_0, minimal, formative) and (P_20, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_20, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U51#) = 2 Thus, we can orient the dependency pairs as follows: nu(U51#(X, mark(Y))) = mark(Y) |> Y = nu(U51#(X, Y)) nu(U51#(X, active(Y))) = active(Y) |> Y = nu(U51#(X, Y)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_20, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative), (P_7, R_0, minimal, formative) and (P_8, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_8, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(isNatIList#) = 1 Thus, we can orient the dependency pairs as follows: nu(isNatIList#(mark(X))) = mark(X) |> X = nu(isNatIList#(X)) nu(isNatIList#(active(X))) = active(X) |> X = nu(isNatIList#(X)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_8, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative), (P_6, R_0, minimal, formative) and (P_7, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_7, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U42#) = 1 Thus, we can orient the dependency pairs as follows: nu(U42#(mark(X))) = mark(X) |> X = nu(U42#(X)) nu(U42#(active(X))) = active(X) |> X = nu(U42#(X)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_7, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative) and (P_6, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_6, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U41#) = 1 Thus, we can orient the dependency pairs as follows: nu(U41#(mark(X), Y)) = mark(X) |> X = nu(U41#(X, Y)) nu(U41#(X, mark(Y))) = X = X = nu(U41#(X, Y)) nu(U41#(active(X), Y)) = active(X) |> X = nu(U41#(X, Y)) nu(U41#(X, active(Y))) = X = X = nu(U41#(X, Y)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_6, R_0, minimal, f) by (P_21, R_0, minimal, f), where P_21 contains: U41#(X, mark(Y)) =#> U41#(X, Y) U41#(X, active(Y)) =#> U41#(X, Y) Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative), (P_5, R_0, minimal, formative) and (P_21, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_21, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U41#) = 2 Thus, we can orient the dependency pairs as follows: nu(U41#(X, mark(Y))) = mark(Y) |> Y = nu(U41#(X, Y)) nu(U41#(X, active(Y))) = active(Y) |> Y = nu(U41#(X, Y)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_21, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative), (P_4, R_0, minimal, formative) and (P_5, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_5, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U31#) = 1 Thus, we can orient the dependency pairs as follows: nu(U31#(mark(X))) = mark(X) |> X = nu(U31#(X)) nu(U31#(active(X))) = active(X) |> X = nu(U31#(X)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_5, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative), (P_3, R_0, minimal, formative) and (P_4, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_4, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U21#) = 1 Thus, we can orient the dependency pairs as follows: nu(U21#(mark(X))) = mark(X) |> X = nu(U21#(X)) nu(U21#(active(X))) = active(X) |> X = nu(U21#(X)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_4, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative), (P_2, R_0, minimal, formative) and (P_3, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_3, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(U11#) = 1 Thus, we can orient the dependency pairs as follows: nu(U11#(mark(X))) = mark(X) |> X = nu(U11#(X)) nu(U11#(active(X))) = active(X) |> X = nu(U11#(X)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_3, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if each of (P_1, R_0, minimal, formative) and (P_2, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_2, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(cons#) = 1 Thus, we can orient the dependency pairs as follows: nu(cons#(mark(X), Y)) = mark(X) |> X = nu(cons#(X, Y)) nu(cons#(X, mark(Y))) = X = X = nu(cons#(X, Y)) nu(cons#(active(X), Y)) = active(X) |> X = nu(cons#(X, Y)) nu(cons#(X, active(Y))) = X = X = nu(cons#(X, Y)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_2, R_0, minimal, f) by (P_22, R_0, minimal, f), where P_22 contains: cons#(X, mark(Y)) =#> cons#(X, Y) cons#(X, active(Y)) =#> cons#(X, Y) Thus, the original system is terminating if each of (P_1, R_0, minimal, formative) and (P_22, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_22, R_0, minimal, formative). We apply the subterm criterion with the following projection function: nu(cons#) = 2 Thus, we can orient the dependency pairs as follows: nu(cons#(X, mark(Y))) = mark(Y) |> Y = nu(cons#(X, Y)) nu(cons#(X, active(Y))) = active(Y) |> Y = nu(cons#(X, Y)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_22, R_0, minimal, f) by ({}, R_0, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. Thus, the original system is terminating if (P_1, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_1, R_0, minimal, formative). We will use the reduction pair processor [Kop12, Thm. 7.16]. It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(zeros) >? mark#(cons(0, zeros)) active#(U41(tt, X)) >? mark#(U42(isNatIList(X))) active#(U51(tt, X)) >? mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) >? mark#(U62(isNat(Y), X)) active#(U62(tt, X)) >? mark#(s(length(X))) active#(isNat(s(X))) >? mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) >? mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) >? mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) >? mark#(U61(isNatList(Y), Y, X)) mark#(zeros) >? active#(zeros) mark#(cons(X, Y)) >? mark#(X) mark#(U11(X)) >? mark#(X) mark#(U21(X)) >? mark#(X) mark#(U31(X)) >? mark#(X) mark#(U41(X, Y)) >? active#(U41(mark(X), Y)) mark#(U41(X, Y)) >? mark#(X) mark#(U42(X)) >? mark#(X) mark#(isNatIList(X)) >? active#(isNatIList(X)) mark#(U51(X, Y)) >? active#(U51(mark(X), Y)) mark#(U51(X, Y)) >? mark#(X) mark#(U52(X)) >? mark#(X) mark#(isNatList(X)) >? active#(isNatList(X)) mark#(U61(X, Y, Z)) >? active#(U61(mark(X), Y, Z)) mark#(U61(X, Y, Z)) >? mark#(X) mark#(U62(X, Y)) >? active#(U62(mark(X), Y)) mark#(U62(X, Y)) >? mark#(X) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) mark#(length(X)) >? active#(length(mark(X))) mark#(length(X)) >? mark#(X) active(zeros) >= mark(cons(0, zeros)) active(U21(tt)) >= mark(tt) active(U41(tt, X)) >= mark(U42(isNatIList(X))) active(U42(tt)) >= mark(tt) active(U51(tt, X)) >= mark(U52(isNatList(X))) active(U52(tt)) >= mark(tt) active(U61(tt, X, Y)) >= mark(U62(isNat(Y), X)) active(U62(tt, X)) >= mark(s(length(X))) active(isNat(0)) >= mark(tt) active(isNat(s(X))) >= mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >= mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >= mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >= mark(U61(isNatList(Y), Y, X)) mark(zeros) >= active(zeros) mark(cons(X, Y)) >= active(cons(mark(X), Y)) mark(0) >= active(0) mark(U11(X)) >= active(U11(mark(X))) mark(tt) >= active(tt) mark(U21(X)) >= active(U21(mark(X))) mark(U31(X)) >= active(U31(mark(X))) mark(U41(X, Y)) >= active(U41(mark(X), Y)) mark(U42(X)) >= active(U42(mark(X))) mark(isNatIList(X)) >= active(isNatIList(X)) mark(U51(X, Y)) >= active(U51(mark(X), Y)) mark(U52(X)) >= active(U52(mark(X))) mark(isNatList(X)) >= active(isNatList(X)) mark(U61(X, Y, Z)) >= active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >= active(U62(mark(X), Y)) mark(isNat(X)) >= active(isNat(X)) mark(s(X)) >= active(s(mark(X))) mark(length(X)) >= active(length(mark(X))) mark(nil) >= active(nil) cons(mark(X), Y) >= cons(X, Y) cons(X, mark(Y)) >= cons(X, Y) cons(active(X), Y) >= cons(X, Y) cons(X, active(Y)) >= cons(X, Y) U11(mark(X)) >= U11(X) U11(active(X)) >= U11(X) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U31(mark(X)) >= U31(X) U31(active(X)) >= U31(X) U41(mark(X), Y) >= U41(X, Y) U41(X, mark(Y)) >= U41(X, Y) U41(active(X), Y) >= U41(X, Y) U41(X, active(Y)) >= U41(X, Y) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) isNatIList(mark(X)) >= isNatIList(X) isNatIList(active(X)) >= isNatIList(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) U61(mark(X), Y, Z) >= U61(X, Y, Z) U61(X, mark(Y), Z) >= U61(X, Y, Z) U61(X, Y, mark(Z)) >= U61(X, Y, Z) U61(active(X), Y, Z) >= U61(X, Y, Z) U61(X, active(Y), Z) >= U61(X, Y, Z) U61(X, Y, active(Z)) >= U61(X, Y, Z) U62(mark(X), Y) >= U62(X, Y) U62(X, mark(Y)) >= U62(X, Y) U62(active(X), Y) >= U62(X, Y) U62(X, active(Y)) >= U62(X, Y) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) length(mark(X)) >= length(X) length(active(X)) >= length(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.y0 U21 = \y0.y0 U31 = \y0.1 + y0 U41 = \y0y1.y0 U42 = \y0.2y0 U51 = \y0y1.y0 U52 = \y0.y0 U61 = \y0y1y2.y0 + 2y1 U62 = \y0y1.y0 + 2y1 active = \y0.y0 active# = \y0.y0 cons = \y0y1.y0 + y1 isNat = \y0.0 isNatIList = \y0.0 isNatList = \y0.0 length = \y0.2y0 mark = \y0.y0 mark# = \y0.y0 nil = 0 s = \y0.y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active#(zeros)]] = 0 >= 0 = [[mark#(cons(0, zeros))]] [[active#(U41(tt, _x0))]] = 0 >= 0 = [[mark#(U42(isNatIList(_x0)))]] [[active#(U51(tt, _x0))]] = 0 >= 0 = [[mark#(U52(isNatList(_x0)))]] [[active#(U61(tt, _x0, _x1))]] = 2x0 >= 2x0 = [[mark#(U62(isNat(_x1), _x0))]] [[active#(U62(tt, _x0))]] = 2x0 >= 2x0 = [[mark#(s(length(_x0)))]] [[active#(isNat(s(_x0)))]] = 0 >= 0 = [[mark#(U21(isNat(_x0)))]] [[active#(isNatIList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U41(isNat(_x0), _x1))]] [[active#(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U51(isNat(_x0), _x1))]] [[active#(length(cons(_x0, _x1)))]] = 2x0 + 2x1 >= 2x1 = [[mark#(U61(isNatList(_x1), _x1, _x0))]] [[mark#(zeros)]] = 0 >= 0 = [[active#(zeros)]] [[mark#(cons(_x0, _x1))]] = x0 + x1 >= x0 = [[mark#(_x0)]] [[mark#(U11(_x0))]] = x0 >= x0 = [[mark#(_x0)]] [[mark#(U21(_x0))]] = x0 >= x0 = [[mark#(_x0)]] [[mark#(U31(_x0))]] = 1 + x0 > x0 = [[mark#(_x0)]] [[mark#(U41(_x0, _x1))]] = x0 >= x0 = [[active#(U41(mark(_x0), _x1))]] [[mark#(U41(_x0, _x1))]] = x0 >= x0 = [[mark#(_x0)]] [[mark#(U42(_x0))]] = 2x0 >= x0 = [[mark#(_x0)]] [[mark#(isNatIList(_x0))]] = 0 >= 0 = [[active#(isNatIList(_x0))]] [[mark#(U51(_x0, _x1))]] = x0 >= x0 = [[active#(U51(mark(_x0), _x1))]] [[mark#(U51(_x0, _x1))]] = x0 >= x0 = [[mark#(_x0)]] [[mark#(U52(_x0))]] = x0 >= x0 = [[mark#(_x0)]] [[mark#(isNatList(_x0))]] = 0 >= 0 = [[active#(isNatList(_x0))]] [[mark#(U61(_x0, _x1, _x2))]] = x0 + 2x1 >= x0 + 2x1 = [[active#(U61(mark(_x0), _x1, _x2))]] [[mark#(U61(_x0, _x1, _x2))]] = x0 + 2x1 >= x0 = [[mark#(_x0)]] [[mark#(U62(_x0, _x1))]] = x0 + 2x1 >= x0 + 2x1 = [[active#(U62(mark(_x0), _x1))]] [[mark#(U62(_x0, _x1))]] = x0 + 2x1 >= x0 = [[mark#(_x0)]] [[mark#(isNat(_x0))]] = 0 >= 0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = x0 >= x0 = [[mark#(_x0)]] [[mark#(length(_x0))]] = 2x0 >= 2x0 = [[active#(length(mark(_x0)))]] [[mark#(length(_x0))]] = 2x0 >= x0 = [[mark#(_x0)]] [[active(zeros)]] = 0 >= 0 = [[mark(cons(0, zeros))]] [[active(U21(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U41(tt, _x0))]] = 0 >= 0 = [[mark(U42(isNatIList(_x0)))]] [[active(U42(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U51(tt, _x0))]] = 0 >= 0 = [[mark(U52(isNatList(_x0)))]] [[active(U52(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U61(tt, _x0, _x1))]] = 2x0 >= 2x0 = [[mark(U62(isNat(_x1), _x0))]] [[active(U62(tt, _x0))]] = 2x0 >= 2x0 = [[mark(s(length(_x0)))]] [[active(isNat(0))]] = 0 >= 0 = [[mark(tt)]] [[active(isNat(s(_x0)))]] = 0 >= 0 = [[mark(U21(isNat(_x0)))]] [[active(isNatIList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark(U41(isNat(_x0), _x1))]] [[active(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark(U51(isNat(_x0), _x1))]] [[active(length(cons(_x0, _x1)))]] = 2x0 + 2x1 >= 2x1 = [[mark(U61(isNatList(_x1), _x1, _x0))]] [[mark(zeros)]] = 0 >= 0 = [[active(zeros)]] [[mark(cons(_x0, _x1))]] = x0 + x1 >= x0 + x1 = [[active(cons(mark(_x0), _x1))]] [[mark(0)]] = 0 >= 0 = [[active(0)]] [[mark(U11(_x0))]] = x0 >= x0 = [[active(U11(mark(_x0)))]] [[mark(tt)]] = 0 >= 0 = [[active(tt)]] [[mark(U21(_x0))]] = x0 >= x0 = [[active(U21(mark(_x0)))]] [[mark(U31(_x0))]] = 1 + x0 >= 1 + x0 = [[active(U31(mark(_x0)))]] [[mark(U41(_x0, _x1))]] = x0 >= x0 = [[active(U41(mark(_x0), _x1))]] [[mark(U42(_x0))]] = 2x0 >= 2x0 = [[active(U42(mark(_x0)))]] [[mark(isNatIList(_x0))]] = 0 >= 0 = [[active(isNatIList(_x0))]] [[mark(U51(_x0, _x1))]] = x0 >= x0 = [[active(U51(mark(_x0), _x1))]] [[mark(U52(_x0))]] = x0 >= x0 = [[active(U52(mark(_x0)))]] [[mark(isNatList(_x0))]] = 0 >= 0 = [[active(isNatList(_x0))]] [[mark(U61(_x0, _x1, _x2))]] = x0 + 2x1 >= x0 + 2x1 = [[active(U61(mark(_x0), _x1, _x2))]] [[mark(U62(_x0, _x1))]] = x0 + 2x1 >= x0 + 2x1 = [[active(U62(mark(_x0), _x1))]] [[mark(isNat(_x0))]] = 0 >= 0 = [[active(isNat(_x0))]] [[mark(s(_x0))]] = x0 >= x0 = [[active(s(mark(_x0)))]] [[mark(length(_x0))]] = 2x0 >= 2x0 = [[active(length(mark(_x0)))]] [[mark(nil)]] = 0 >= 0 = [[active(nil)]] [[cons(mark(_x0), _x1)]] = x0 + x1 >= x0 + x1 = [[cons(_x0, _x1)]] [[cons(_x0, mark(_x1))]] = x0 + x1 >= x0 + x1 = [[cons(_x0, _x1)]] [[cons(active(_x0), _x1)]] = x0 + x1 >= x0 + x1 = [[cons(_x0, _x1)]] [[cons(_x0, active(_x1))]] = x0 + x1 >= x0 + x1 = [[cons(_x0, _x1)]] [[U11(mark(_x0))]] = x0 >= x0 = [[U11(_x0)]] [[U11(active(_x0))]] = x0 >= x0 = [[U11(_x0)]] [[U21(mark(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U21(active(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U31(mark(_x0))]] = 1 + x0 >= 1 + x0 = [[U31(_x0)]] [[U31(active(_x0))]] = 1 + x0 >= 1 + x0 = [[U31(_x0)]] [[U41(mark(_x0), _x1)]] = x0 >= x0 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = x0 >= x0 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = x0 >= x0 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = x0 >= x0 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = 2x0 >= 2x0 = [[U42(_x0)]] [[U42(active(_x0))]] = 2x0 >= 2x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = x0 + 2x1 >= x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = x0 + 2x1 >= x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = x0 + 2x1 >= x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = x0 + 2x1 >= x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = x0 + 2x1 >= x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = x0 + 2x1 >= x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[s(mark(_x0))]] = x0 >= x0 = [[s(_x0)]] [[s(active(_x0))]] = x0 >= x0 = [[s(_x0)]] [[length(mark(_x0))]] = 2x0 >= 2x0 = [[length(_x0)]] [[length(active(_x0))]] = 2x0 >= 2x0 = [[length(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_1, R_0, minimal, formative) by (P_23, R_0, minimal, formative), where P_23 consists of: active#(zeros) =#> mark#(cons(0, zeros)) active#(U41(tt, X)) =#> mark#(U42(isNatIList(X))) active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) =#> mark#(U62(isNat(Y), X)) active#(U62(tt, X)) =#> mark#(s(length(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) =#> mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) =#> mark#(U61(isNatList(Y), Y, X)) mark#(zeros) =#> active#(zeros) mark#(cons(X, Y)) =#> mark#(X) mark#(U11(X)) =#> mark#(X) mark#(U21(X)) =#> mark#(X) mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) mark#(U41(X, Y)) =#> mark#(X) mark#(U42(X)) =#> mark#(X) mark#(isNatIList(X)) =#> active#(isNatIList(X)) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U51(X, Y)) =#> mark#(X) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(U61(X, Y, Z)) =#> active#(U61(mark(X), Y, Z)) mark#(U61(X, Y, Z)) =#> mark#(X) mark#(U62(X, Y)) =#> active#(U62(mark(X), Y)) mark#(U62(X, Y)) =#> mark#(X) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) mark#(length(X)) =#> active#(length(mark(X))) mark#(length(X)) =#> mark#(X) Thus, the original system is terminating if (P_23, R_0, minimal, formative) is finite. We consider the dependency pair problem (P_23, R_0, minimal, formative). The formative rules of (P_23, R_0) are R_1 ::= active(zeros) => mark(cons(0, zeros)) active(U21(tt)) => mark(tt) active(U41(tt, X)) => mark(U42(isNatIList(X))) active(U42(tt)) => mark(tt) active(U51(tt, X)) => mark(U52(isNatList(X))) active(U52(tt)) => mark(tt) active(U61(tt, X, Y)) => mark(U62(isNat(Y), X)) active(U62(tt, X)) => mark(s(length(X))) active(isNat(0)) => mark(tt) active(isNat(s(X))) => mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) => mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) => mark(U51(isNat(X), Y)) active(length(cons(X, Y))) => mark(U61(isNatList(Y), Y, X)) mark(zeros) => active(zeros) mark(cons(X, Y)) => active(cons(mark(X), Y)) mark(0) => active(0) mark(U11(X)) => active(U11(mark(X))) mark(tt) => active(tt) mark(U21(X)) => active(U21(mark(X))) mark(U31(X)) => active(U31(mark(X))) mark(U41(X, Y)) => active(U41(mark(X), Y)) mark(U42(X)) => active(U42(mark(X))) mark(isNatIList(X)) => active(isNatIList(X)) mark(U51(X, Y)) => active(U51(mark(X), Y)) mark(U52(X)) => active(U52(mark(X))) mark(isNatList(X)) => active(isNatList(X)) mark(U61(X, Y, Z)) => active(U61(mark(X), Y, Z)) mark(U62(X, Y)) => active(U62(mark(X), Y)) mark(isNat(X)) => active(isNat(X)) mark(s(X)) => active(s(mark(X))) mark(length(X)) => active(length(mark(X))) mark(nil) => active(nil) cons(mark(X), Y) => cons(X, Y) cons(X, mark(Y)) => cons(X, Y) cons(active(X), Y) => cons(X, Y) cons(X, active(Y)) => cons(X, Y) U11(mark(X)) => U11(X) U11(active(X)) => U11(X) U21(mark(X)) => U21(X) U21(active(X)) => U21(X) U41(mark(X), Y) => U41(X, Y) U41(X, mark(Y)) => U41(X, Y) U41(active(X), Y) => U41(X, Y) U41(X, active(Y)) => U41(X, Y) U42(mark(X)) => U42(X) U42(active(X)) => U42(X) isNatIList(mark(X)) => isNatIList(X) isNatIList(active(X)) => isNatIList(X) U51(mark(X), Y) => U51(X, Y) U51(X, mark(Y)) => U51(X, Y) U51(active(X), Y) => U51(X, Y) U51(X, active(Y)) => U51(X, Y) U52(mark(X)) => U52(X) U52(active(X)) => U52(X) isNatList(mark(X)) => isNatList(X) isNatList(active(X)) => isNatList(X) U61(mark(X), Y, Z) => U61(X, Y, Z) U61(X, mark(Y), Z) => U61(X, Y, Z) U61(X, Y, mark(Z)) => U61(X, Y, Z) U61(active(X), Y, Z) => U61(X, Y, Z) U61(X, active(Y), Z) => U61(X, Y, Z) U61(X, Y, active(Z)) => U61(X, Y, Z) U62(mark(X), Y) => U62(X, Y) U62(X, mark(Y)) => U62(X, Y) U62(active(X), Y) => U62(X, Y) U62(X, active(Y)) => U62(X, Y) isNat(mark(X)) => isNat(X) isNat(active(X)) => isNat(X) s(mark(X)) => s(X) s(active(X)) => s(X) length(mark(X)) => length(X) length(active(X)) => length(X) By [Kop12, Thm. 7.17], we may replace the dependency pair problem (P_23, R_0, minimal, formative) by (P_23, R_1, minimal, formative). Thus, the original system is terminating if (P_23, R_1, minimal, formative) is finite. We consider the dependency pair problem (P_23, R_1, minimal, formative). We will use the reduction pair processor [Kop12, Thm. 7.16]. It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(zeros) >? mark#(cons(0, zeros)) active#(U41(tt, X)) >? mark#(U42(isNatIList(X))) active#(U51(tt, X)) >? mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) >? mark#(U62(isNat(Y), X)) active#(U62(tt, X)) >? mark#(s(length(X))) active#(isNat(s(X))) >? mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) >? mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) >? mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) >? mark#(U61(isNatList(Y), Y, X)) mark#(zeros) >? active#(zeros) mark#(cons(X, Y)) >? mark#(X) mark#(U11(X)) >? mark#(X) mark#(U21(X)) >? mark#(X) mark#(U41(X, Y)) >? active#(U41(mark(X), Y)) mark#(U41(X, Y)) >? mark#(X) mark#(U42(X)) >? mark#(X) mark#(isNatIList(X)) >? active#(isNatIList(X)) mark#(U51(X, Y)) >? active#(U51(mark(X), Y)) mark#(U51(X, Y)) >? mark#(X) mark#(U52(X)) >? mark#(X) mark#(isNatList(X)) >? active#(isNatList(X)) mark#(U61(X, Y, Z)) >? active#(U61(mark(X), Y, Z)) mark#(U61(X, Y, Z)) >? mark#(X) mark#(U62(X, Y)) >? active#(U62(mark(X), Y)) mark#(U62(X, Y)) >? mark#(X) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) mark#(length(X)) >? active#(length(mark(X))) mark#(length(X)) >? mark#(X) active(zeros) >= mark(cons(0, zeros)) active(U21(tt)) >= mark(tt) active(U41(tt, X)) >= mark(U42(isNatIList(X))) active(U42(tt)) >= mark(tt) active(U51(tt, X)) >= mark(U52(isNatList(X))) active(U52(tt)) >= mark(tt) active(U61(tt, X, Y)) >= mark(U62(isNat(Y), X)) active(U62(tt, X)) >= mark(s(length(X))) active(isNat(0)) >= mark(tt) active(isNat(s(X))) >= mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >= mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >= mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >= mark(U61(isNatList(Y), Y, X)) mark(zeros) >= active(zeros) mark(cons(X, Y)) >= active(cons(mark(X), Y)) mark(0) >= active(0) mark(U11(X)) >= active(U11(mark(X))) mark(tt) >= active(tt) mark(U21(X)) >= active(U21(mark(X))) mark(U31(X)) >= active(U31(mark(X))) mark(U41(X, Y)) >= active(U41(mark(X), Y)) mark(U42(X)) >= active(U42(mark(X))) mark(isNatIList(X)) >= active(isNatIList(X)) mark(U51(X, Y)) >= active(U51(mark(X), Y)) mark(U52(X)) >= active(U52(mark(X))) mark(isNatList(X)) >= active(isNatList(X)) mark(U61(X, Y, Z)) >= active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >= active(U62(mark(X), Y)) mark(isNat(X)) >= active(isNat(X)) mark(s(X)) >= active(s(mark(X))) mark(length(X)) >= active(length(mark(X))) mark(nil) >= active(nil) cons(mark(X), Y) >= cons(X, Y) cons(X, mark(Y)) >= cons(X, Y) cons(active(X), Y) >= cons(X, Y) cons(X, active(Y)) >= cons(X, Y) U11(mark(X)) >= U11(X) U11(active(X)) >= U11(X) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U41(mark(X), Y) >= U41(X, Y) U41(X, mark(Y)) >= U41(X, Y) U41(active(X), Y) >= U41(X, Y) U41(X, active(Y)) >= U41(X, Y) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) isNatIList(mark(X)) >= isNatIList(X) isNatIList(active(X)) >= isNatIList(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) U61(mark(X), Y, Z) >= U61(X, Y, Z) U61(X, mark(Y), Z) >= U61(X, Y, Z) U61(X, Y, mark(Z)) >= U61(X, Y, Z) U61(active(X), Y, Z) >= U61(X, Y, Z) U61(X, active(Y), Z) >= U61(X, Y, Z) U61(X, Y, active(Z)) >= U61(X, Y, Z) U62(mark(X), Y) >= U62(X, Y) U62(X, mark(Y)) >= U62(X, Y) U62(active(X), Y) >= U62(X, Y) U62(X, active(Y)) >= U62(X, Y) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) length(mark(X)) >= length(X) length(active(X)) >= length(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.y0 U21 = \y0.2y0 U31 = \y0.0 U41 = \y0y1.1 + 2y0 U42 = \y0.y0 U51 = \y0y1.y0 U52 = \y0.y0 U61 = \y0y1y2.2y0 + 2y1 U62 = \y0y1.y0 + 2y1 active = \y0.y0 active# = \y0.2y0 cons = \y0y1.y0 + y1 isNat = \y0.0 isNatIList = \y0.1 isNatList = \y0.0 length = \y0.2y0 mark = \y0.y0 mark# = \y0.2y0 nil = 0 s = \y0.y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active#(zeros)]] = 0 >= 0 = [[mark#(cons(0, zeros))]] [[active#(U41(tt, _x0))]] = 2 >= 2 = [[mark#(U42(isNatIList(_x0)))]] [[active#(U51(tt, _x0))]] = 0 >= 0 = [[mark#(U52(isNatList(_x0)))]] [[active#(U61(tt, _x0, _x1))]] = 4x0 >= 4x0 = [[mark#(U62(isNat(_x1), _x0))]] [[active#(U62(tt, _x0))]] = 4x0 >= 4x0 = [[mark#(s(length(_x0)))]] [[active#(isNat(s(_x0)))]] = 0 >= 0 = [[mark#(U21(isNat(_x0)))]] [[active#(isNatIList(cons(_x0, _x1)))]] = 2 >= 2 = [[mark#(U41(isNat(_x0), _x1))]] [[active#(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U51(isNat(_x0), _x1))]] [[active#(length(cons(_x0, _x1)))]] = 4x0 + 4x1 >= 4x1 = [[mark#(U61(isNatList(_x1), _x1, _x0))]] [[mark#(zeros)]] = 0 >= 0 = [[active#(zeros)]] [[mark#(cons(_x0, _x1))]] = 2x0 + 2x1 >= 2x0 = [[mark#(_x0)]] [[mark#(U11(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U21(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U41(_x0, _x1))]] = 2 + 4x0 >= 2 + 4x0 = [[active#(U41(mark(_x0), _x1))]] [[mark#(U41(_x0, _x1))]] = 2 + 4x0 > 2x0 = [[mark#(_x0)]] [[mark#(U42(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatIList(_x0))]] = 2 >= 2 = [[active#(isNatIList(_x0))]] [[mark#(U51(_x0, _x1))]] = 2x0 >= 2x0 = [[active#(U51(mark(_x0), _x1))]] [[mark#(U51(_x0, _x1))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U52(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatList(_x0))]] = 0 >= 0 = [[active#(isNatList(_x0))]] [[mark#(U61(_x0, _x1, _x2))]] = 4x0 + 4x1 >= 4x0 + 4x1 = [[active#(U61(mark(_x0), _x1, _x2))]] [[mark#(U61(_x0, _x1, _x2))]] = 4x0 + 4x1 >= 2x0 = [[mark#(_x0)]] [[mark#(U62(_x0, _x1))]] = 2x0 + 4x1 >= 2x0 + 4x1 = [[active#(U62(mark(_x0), _x1))]] [[mark#(U62(_x0, _x1))]] = 2x0 + 4x1 >= 2x0 = [[mark#(_x0)]] [[mark#(isNat(_x0))]] = 0 >= 0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(length(_x0))]] = 4x0 >= 4x0 = [[active#(length(mark(_x0)))]] [[mark#(length(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[active(zeros)]] = 0 >= 0 = [[mark(cons(0, zeros))]] [[active(U21(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U41(tt, _x0))]] = 1 >= 1 = [[mark(U42(isNatIList(_x0)))]] [[active(U42(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U51(tt, _x0))]] = 0 >= 0 = [[mark(U52(isNatList(_x0)))]] [[active(U52(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U61(tt, _x0, _x1))]] = 2x0 >= 2x0 = [[mark(U62(isNat(_x1), _x0))]] [[active(U62(tt, _x0))]] = 2x0 >= 2x0 = [[mark(s(length(_x0)))]] [[active(isNat(0))]] = 0 >= 0 = [[mark(tt)]] [[active(isNat(s(_x0)))]] = 0 >= 0 = [[mark(U21(isNat(_x0)))]] [[active(isNatIList(cons(_x0, _x1)))]] = 1 >= 1 = [[mark(U41(isNat(_x0), _x1))]] [[active(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark(U51(isNat(_x0), _x1))]] [[active(length(cons(_x0, _x1)))]] = 2x0 + 2x1 >= 2x1 = [[mark(U61(isNatList(_x1), _x1, _x0))]] [[mark(zeros)]] = 0 >= 0 = [[active(zeros)]] [[mark(cons(_x0, _x1))]] = x0 + x1 >= x0 + x1 = [[active(cons(mark(_x0), _x1))]] [[mark(0)]] = 0 >= 0 = [[active(0)]] [[mark(U11(_x0))]] = x0 >= x0 = [[active(U11(mark(_x0)))]] [[mark(tt)]] = 0 >= 0 = [[active(tt)]] [[mark(U21(_x0))]] = 2x0 >= 2x0 = [[active(U21(mark(_x0)))]] [[mark(U31(_x0))]] = 0 >= 0 = [[active(U31(mark(_x0)))]] [[mark(U41(_x0, _x1))]] = 1 + 2x0 >= 1 + 2x0 = [[active(U41(mark(_x0), _x1))]] [[mark(U42(_x0))]] = x0 >= x0 = [[active(U42(mark(_x0)))]] [[mark(isNatIList(_x0))]] = 1 >= 1 = [[active(isNatIList(_x0))]] [[mark(U51(_x0, _x1))]] = x0 >= x0 = [[active(U51(mark(_x0), _x1))]] [[mark(U52(_x0))]] = x0 >= x0 = [[active(U52(mark(_x0)))]] [[mark(isNatList(_x0))]] = 0 >= 0 = [[active(isNatList(_x0))]] [[mark(U61(_x0, _x1, _x2))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[active(U61(mark(_x0), _x1, _x2))]] [[mark(U62(_x0, _x1))]] = x0 + 2x1 >= x0 + 2x1 = [[active(U62(mark(_x0), _x1))]] [[mark(isNat(_x0))]] = 0 >= 0 = [[active(isNat(_x0))]] [[mark(s(_x0))]] = x0 >= x0 = [[active(s(mark(_x0)))]] [[mark(length(_x0))]] = 2x0 >= 2x0 = [[active(length(mark(_x0)))]] [[mark(nil)]] = 0 >= 0 = [[active(nil)]] [[cons(mark(_x0), _x1)]] = x0 + x1 >= x0 + x1 = [[cons(_x0, _x1)]] [[cons(_x0, mark(_x1))]] = x0 + x1 >= x0 + x1 = [[cons(_x0, _x1)]] [[cons(active(_x0), _x1)]] = x0 + x1 >= x0 + x1 = [[cons(_x0, _x1)]] [[cons(_x0, active(_x1))]] = x0 + x1 >= x0 + x1 = [[cons(_x0, _x1)]] [[U11(mark(_x0))]] = x0 >= x0 = [[U11(_x0)]] [[U11(active(_x0))]] = x0 >= x0 = [[U11(_x0)]] [[U21(mark(_x0))]] = 2x0 >= 2x0 = [[U21(_x0)]] [[U21(active(_x0))]] = 2x0 >= 2x0 = [[U21(_x0)]] [[U41(mark(_x0), _x1)]] = 1 + 2x0 >= 1 + 2x0 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = 1 + 2x0 >= 1 + 2x0 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = 1 + 2x0 >= 1 + 2x0 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = 1 + 2x0 >= 1 + 2x0 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[U42(active(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = 1 >= 1 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = 1 >= 1 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = 2x0 + 2x1 >= 2x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[s(mark(_x0))]] = x0 >= x0 = [[s(_x0)]] [[s(active(_x0))]] = x0 >= x0 = [[s(_x0)]] [[length(mark(_x0))]] = 2x0 >= 2x0 = [[length(_x0)]] [[length(active(_x0))]] = 2x0 >= 2x0 = [[length(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_23, R_1, minimal, formative) by (P_24, R_1, minimal, formative), where P_24 consists of: active#(zeros) =#> mark#(cons(0, zeros)) active#(U41(tt, X)) =#> mark#(U42(isNatIList(X))) active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) =#> mark#(U62(isNat(Y), X)) active#(U62(tt, X)) =#> mark#(s(length(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) =#> mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) =#> mark#(U61(isNatList(Y), Y, X)) mark#(zeros) =#> active#(zeros) mark#(cons(X, Y)) =#> mark#(X) mark#(U11(X)) =#> mark#(X) mark#(U21(X)) =#> mark#(X) mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) mark#(U42(X)) =#> mark#(X) mark#(isNatIList(X)) =#> active#(isNatIList(X)) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U51(X, Y)) =#> mark#(X) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(U61(X, Y, Z)) =#> active#(U61(mark(X), Y, Z)) mark#(U61(X, Y, Z)) =#> mark#(X) mark#(U62(X, Y)) =#> active#(U62(mark(X), Y)) mark#(U62(X, Y)) =#> mark#(X) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) mark#(length(X)) =#> active#(length(mark(X))) mark#(length(X)) =#> mark#(X) Thus, the original system is terminating if (P_24, R_1, minimal, formative) is finite. We consider the dependency pair problem (P_24, R_1, minimal, formative). We will use the reduction pair processor [Kop12, Thm. 7.16]. It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(zeros) >? mark#(cons(0, zeros)) active#(U41(tt, X)) >? mark#(U42(isNatIList(X))) active#(U51(tt, X)) >? mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) >? mark#(U62(isNat(Y), X)) active#(U62(tt, X)) >? mark#(s(length(X))) active#(isNat(s(X))) >? mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) >? mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) >? mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) >? mark#(U61(isNatList(Y), Y, X)) mark#(zeros) >? active#(zeros) mark#(cons(X, Y)) >? mark#(X) mark#(U11(X)) >? mark#(X) mark#(U21(X)) >? mark#(X) mark#(U41(X, Y)) >? active#(U41(mark(X), Y)) mark#(U42(X)) >? mark#(X) mark#(isNatIList(X)) >? active#(isNatIList(X)) mark#(U51(X, Y)) >? active#(U51(mark(X), Y)) mark#(U51(X, Y)) >? mark#(X) mark#(U52(X)) >? mark#(X) mark#(isNatList(X)) >? active#(isNatList(X)) mark#(U61(X, Y, Z)) >? active#(U61(mark(X), Y, Z)) mark#(U61(X, Y, Z)) >? mark#(X) mark#(U62(X, Y)) >? active#(U62(mark(X), Y)) mark#(U62(X, Y)) >? mark#(X) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) mark#(length(X)) >? active#(length(mark(X))) mark#(length(X)) >? mark#(X) active(zeros) >= mark(cons(0, zeros)) active(U21(tt)) >= mark(tt) active(U41(tt, X)) >= mark(U42(isNatIList(X))) active(U42(tt)) >= mark(tt) active(U51(tt, X)) >= mark(U52(isNatList(X))) active(U52(tt)) >= mark(tt) active(U61(tt, X, Y)) >= mark(U62(isNat(Y), X)) active(U62(tt, X)) >= mark(s(length(X))) active(isNat(0)) >= mark(tt) active(isNat(s(X))) >= mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >= mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >= mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >= mark(U61(isNatList(Y), Y, X)) mark(zeros) >= active(zeros) mark(cons(X, Y)) >= active(cons(mark(X), Y)) mark(0) >= active(0) mark(U11(X)) >= active(U11(mark(X))) mark(tt) >= active(tt) mark(U21(X)) >= active(U21(mark(X))) mark(U31(X)) >= active(U31(mark(X))) mark(U41(X, Y)) >= active(U41(mark(X), Y)) mark(U42(X)) >= active(U42(mark(X))) mark(isNatIList(X)) >= active(isNatIList(X)) mark(U51(X, Y)) >= active(U51(mark(X), Y)) mark(U52(X)) >= active(U52(mark(X))) mark(isNatList(X)) >= active(isNatList(X)) mark(U61(X, Y, Z)) >= active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >= active(U62(mark(X), Y)) mark(isNat(X)) >= active(isNat(X)) mark(s(X)) >= active(s(mark(X))) mark(length(X)) >= active(length(mark(X))) mark(nil) >= active(nil) cons(mark(X), Y) >= cons(X, Y) cons(X, mark(Y)) >= cons(X, Y) cons(active(X), Y) >= cons(X, Y) cons(X, active(Y)) >= cons(X, Y) U11(mark(X)) >= U11(X) U11(active(X)) >= U11(X) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U41(mark(X), Y) >= U41(X, Y) U41(X, mark(Y)) >= U41(X, Y) U41(active(X), Y) >= U41(X, Y) U41(X, active(Y)) >= U41(X, Y) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) isNatIList(mark(X)) >= isNatIList(X) isNatIList(active(X)) >= isNatIList(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) U61(mark(X), Y, Z) >= U61(X, Y, Z) U61(X, mark(Y), Z) >= U61(X, Y, Z) U61(X, Y, mark(Z)) >= U61(X, Y, Z) U61(active(X), Y, Z) >= U61(X, Y, Z) U61(X, active(Y), Z) >= U61(X, Y, Z) U61(X, Y, active(Z)) >= U61(X, Y, Z) U62(mark(X), Y) >= U62(X, Y) U62(X, mark(Y)) >= U62(X, Y) U62(active(X), Y) >= U62(X, Y) U62(X, active(Y)) >= U62(X, Y) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) length(mark(X)) >= length(X) length(active(X)) >= length(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.2 + y0 U21 = \y0.y0 U31 = \y0.0 U41 = \y0y1.0 U42 = \y0.2y0 U51 = \y0y1.2y0 U52 = \y0.y0 U61 = \y0y1y2.y0 + 2y1 U62 = \y0y1.y0 + 2y1 active = \y0.y0 active# = \y0.2y0 cons = \y0y1.y0 + 2y1 isNat = \y0.0 isNatIList = \y0.0 isNatList = \y0.0 length = \y0.y0 mark = \y0.y0 mark# = \y0.2y0 nil = 0 s = \y0.2y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active#(zeros)]] = 0 >= 0 = [[mark#(cons(0, zeros))]] [[active#(U41(tt, _x0))]] = 0 >= 0 = [[mark#(U42(isNatIList(_x0)))]] [[active#(U51(tt, _x0))]] = 0 >= 0 = [[mark#(U52(isNatList(_x0)))]] [[active#(U61(tt, _x0, _x1))]] = 4x0 >= 4x0 = [[mark#(U62(isNat(_x1), _x0))]] [[active#(U62(tt, _x0))]] = 4x0 >= 4x0 = [[mark#(s(length(_x0)))]] [[active#(isNat(s(_x0)))]] = 0 >= 0 = [[mark#(U21(isNat(_x0)))]] [[active#(isNatIList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U41(isNat(_x0), _x1))]] [[active#(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U51(isNat(_x0), _x1))]] [[active#(length(cons(_x0, _x1)))]] = 2x0 + 4x1 >= 4x1 = [[mark#(U61(isNatList(_x1), _x1, _x0))]] [[mark#(zeros)]] = 0 >= 0 = [[active#(zeros)]] [[mark#(cons(_x0, _x1))]] = 2x0 + 4x1 >= 2x0 = [[mark#(_x0)]] [[mark#(U11(_x0))]] = 4 + 2x0 > 2x0 = [[mark#(_x0)]] [[mark#(U21(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U41(_x0, _x1))]] = 0 >= 0 = [[active#(U41(mark(_x0), _x1))]] [[mark#(U42(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatIList(_x0))]] = 0 >= 0 = [[active#(isNatIList(_x0))]] [[mark#(U51(_x0, _x1))]] = 4x0 >= 4x0 = [[active#(U51(mark(_x0), _x1))]] [[mark#(U51(_x0, _x1))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U52(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatList(_x0))]] = 0 >= 0 = [[active#(isNatList(_x0))]] [[mark#(U61(_x0, _x1, _x2))]] = 2x0 + 4x1 >= 2x0 + 4x1 = [[active#(U61(mark(_x0), _x1, _x2))]] [[mark#(U61(_x0, _x1, _x2))]] = 2x0 + 4x1 >= 2x0 = [[mark#(_x0)]] [[mark#(U62(_x0, _x1))]] = 2x0 + 4x1 >= 2x0 + 4x1 = [[active#(U62(mark(_x0), _x1))]] [[mark#(U62(_x0, _x1))]] = 2x0 + 4x1 >= 2x0 = [[mark#(_x0)]] [[mark#(isNat(_x0))]] = 0 >= 0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(length(_x0))]] = 2x0 >= 2x0 = [[active#(length(mark(_x0)))]] [[mark#(length(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[active(zeros)]] = 0 >= 0 = [[mark(cons(0, zeros))]] [[active(U21(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U41(tt, _x0))]] = 0 >= 0 = [[mark(U42(isNatIList(_x0)))]] [[active(U42(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U51(tt, _x0))]] = 0 >= 0 = [[mark(U52(isNatList(_x0)))]] [[active(U52(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U61(tt, _x0, _x1))]] = 2x0 >= 2x0 = [[mark(U62(isNat(_x1), _x0))]] [[active(U62(tt, _x0))]] = 2x0 >= 2x0 = [[mark(s(length(_x0)))]] [[active(isNat(0))]] = 0 >= 0 = [[mark(tt)]] [[active(isNat(s(_x0)))]] = 0 >= 0 = [[mark(U21(isNat(_x0)))]] [[active(isNatIList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark(U41(isNat(_x0), _x1))]] [[active(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark(U51(isNat(_x0), _x1))]] [[active(length(cons(_x0, _x1)))]] = x0 + 2x1 >= 2x1 = [[mark(U61(isNatList(_x1), _x1, _x0))]] [[mark(zeros)]] = 0 >= 0 = [[active(zeros)]] [[mark(cons(_x0, _x1))]] = x0 + 2x1 >= x0 + 2x1 = [[active(cons(mark(_x0), _x1))]] [[mark(0)]] = 0 >= 0 = [[active(0)]] [[mark(U11(_x0))]] = 2 + x0 >= 2 + x0 = [[active(U11(mark(_x0)))]] [[mark(tt)]] = 0 >= 0 = [[active(tt)]] [[mark(U21(_x0))]] = x0 >= x0 = [[active(U21(mark(_x0)))]] [[mark(U31(_x0))]] = 0 >= 0 = [[active(U31(mark(_x0)))]] [[mark(U41(_x0, _x1))]] = 0 >= 0 = [[active(U41(mark(_x0), _x1))]] [[mark(U42(_x0))]] = 2x0 >= 2x0 = [[active(U42(mark(_x0)))]] [[mark(isNatIList(_x0))]] = 0 >= 0 = [[active(isNatIList(_x0))]] [[mark(U51(_x0, _x1))]] = 2x0 >= 2x0 = [[active(U51(mark(_x0), _x1))]] [[mark(U52(_x0))]] = x0 >= x0 = [[active(U52(mark(_x0)))]] [[mark(isNatList(_x0))]] = 0 >= 0 = [[active(isNatList(_x0))]] [[mark(U61(_x0, _x1, _x2))]] = x0 + 2x1 >= x0 + 2x1 = [[active(U61(mark(_x0), _x1, _x2))]] [[mark(U62(_x0, _x1))]] = x0 + 2x1 >= x0 + 2x1 = [[active(U62(mark(_x0), _x1))]] [[mark(isNat(_x0))]] = 0 >= 0 = [[active(isNat(_x0))]] [[mark(s(_x0))]] = 2x0 >= 2x0 = [[active(s(mark(_x0)))]] [[mark(length(_x0))]] = x0 >= x0 = [[active(length(mark(_x0)))]] [[mark(nil)]] = 0 >= 0 = [[active(nil)]] [[cons(mark(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(_x0, mark(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(active(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[cons(_x0, _x1)]] [[cons(_x0, active(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[cons(_x0, _x1)]] [[U11(mark(_x0))]] = 2 + x0 >= 2 + x0 = [[U11(_x0)]] [[U11(active(_x0))]] = 2 + x0 >= 2 + x0 = [[U11(_x0)]] [[U21(mark(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U21(active(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U41(mark(_x0), _x1)]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = 2x0 >= 2x0 = [[U42(_x0)]] [[U42(active(_x0))]] = 2x0 >= 2x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = 2x0 >= 2x0 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = 2x0 >= 2x0 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = 2x0 >= 2x0 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = 2x0 >= 2x0 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = x0 + 2x1 >= x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = x0 + 2x1 >= x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = x0 + 2x1 >= x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = x0 + 2x1 >= x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = x0 + 2x1 >= x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = x0 + 2x1 >= x0 + 2x1 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = x0 + 2x1 >= x0 + 2x1 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[s(mark(_x0))]] = 2x0 >= 2x0 = [[s(_x0)]] [[s(active(_x0))]] = 2x0 >= 2x0 = [[s(_x0)]] [[length(mark(_x0))]] = x0 >= x0 = [[length(_x0)]] [[length(active(_x0))]] = x0 >= x0 = [[length(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_24, R_1, minimal, formative) by (P_25, R_1, minimal, formative), where P_25 consists of: active#(zeros) =#> mark#(cons(0, zeros)) active#(U41(tt, X)) =#> mark#(U42(isNatIList(X))) active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) =#> mark#(U62(isNat(Y), X)) active#(U62(tt, X)) =#> mark#(s(length(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) =#> mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) =#> mark#(U61(isNatList(Y), Y, X)) mark#(zeros) =#> active#(zeros) mark#(cons(X, Y)) =#> mark#(X) mark#(U21(X)) =#> mark#(X) mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) mark#(U42(X)) =#> mark#(X) mark#(isNatIList(X)) =#> active#(isNatIList(X)) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U51(X, Y)) =#> mark#(X) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(U61(X, Y, Z)) =#> active#(U61(mark(X), Y, Z)) mark#(U61(X, Y, Z)) =#> mark#(X) mark#(U62(X, Y)) =#> active#(U62(mark(X), Y)) mark#(U62(X, Y)) =#> mark#(X) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) mark#(length(X)) =#> active#(length(mark(X))) mark#(length(X)) =#> mark#(X) Thus, the original system is terminating if (P_25, R_1, minimal, formative) is finite. We consider the dependency pair problem (P_25, R_1, minimal, formative). The formative rules of (P_25, R_1) are R_2 ::= active(zeros) => mark(cons(0, zeros)) active(U21(tt)) => mark(tt) active(U41(tt, X)) => mark(U42(isNatIList(X))) active(U42(tt)) => mark(tt) active(U51(tt, X)) => mark(U52(isNatList(X))) active(U52(tt)) => mark(tt) active(U61(tt, X, Y)) => mark(U62(isNat(Y), X)) active(U62(tt, X)) => mark(s(length(X))) active(isNat(0)) => mark(tt) active(isNat(s(X))) => mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) => mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) => mark(U51(isNat(X), Y)) active(length(cons(X, Y))) => mark(U61(isNatList(Y), Y, X)) mark(zeros) => active(zeros) mark(cons(X, Y)) => active(cons(mark(X), Y)) mark(0) => active(0) mark(U11(X)) => active(U11(mark(X))) mark(tt) => active(tt) mark(U21(X)) => active(U21(mark(X))) mark(U31(X)) => active(U31(mark(X))) mark(U41(X, Y)) => active(U41(mark(X), Y)) mark(U42(X)) => active(U42(mark(X))) mark(isNatIList(X)) => active(isNatIList(X)) mark(U51(X, Y)) => active(U51(mark(X), Y)) mark(U52(X)) => active(U52(mark(X))) mark(isNatList(X)) => active(isNatList(X)) mark(U61(X, Y, Z)) => active(U61(mark(X), Y, Z)) mark(U62(X, Y)) => active(U62(mark(X), Y)) mark(isNat(X)) => active(isNat(X)) mark(s(X)) => active(s(mark(X))) mark(length(X)) => active(length(mark(X))) mark(nil) => active(nil) cons(mark(X), Y) => cons(X, Y) cons(X, mark(Y)) => cons(X, Y) cons(active(X), Y) => cons(X, Y) cons(X, active(Y)) => cons(X, Y) U21(mark(X)) => U21(X) U21(active(X)) => U21(X) U41(mark(X), Y) => U41(X, Y) U41(X, mark(Y)) => U41(X, Y) U41(active(X), Y) => U41(X, Y) U41(X, active(Y)) => U41(X, Y) U42(mark(X)) => U42(X) U42(active(X)) => U42(X) isNatIList(mark(X)) => isNatIList(X) isNatIList(active(X)) => isNatIList(X) U51(mark(X), Y) => U51(X, Y) U51(X, mark(Y)) => U51(X, Y) U51(active(X), Y) => U51(X, Y) U51(X, active(Y)) => U51(X, Y) U52(mark(X)) => U52(X) U52(active(X)) => U52(X) isNatList(mark(X)) => isNatList(X) isNatList(active(X)) => isNatList(X) U61(mark(X), Y, Z) => U61(X, Y, Z) U61(X, mark(Y), Z) => U61(X, Y, Z) U61(X, Y, mark(Z)) => U61(X, Y, Z) U61(active(X), Y, Z) => U61(X, Y, Z) U61(X, active(Y), Z) => U61(X, Y, Z) U61(X, Y, active(Z)) => U61(X, Y, Z) U62(mark(X), Y) => U62(X, Y) U62(X, mark(Y)) => U62(X, Y) U62(active(X), Y) => U62(X, Y) U62(X, active(Y)) => U62(X, Y) isNat(mark(X)) => isNat(X) isNat(active(X)) => isNat(X) s(mark(X)) => s(X) s(active(X)) => s(X) length(mark(X)) => length(X) length(active(X)) => length(X) By [Kop12, Thm. 7.17], we may replace the dependency pair problem (P_25, R_1, minimal, formative) by (P_25, R_2, minimal, formative). Thus, the original system is terminating if (P_25, R_2, minimal, formative) is finite. We consider the dependency pair problem (P_25, R_2, minimal, formative). We will use the reduction pair processor [Kop12, Thm. 7.16]. It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(zeros) >? mark#(cons(0, zeros)) active#(U41(tt, X)) >? mark#(U42(isNatIList(X))) active#(U51(tt, X)) >? mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) >? mark#(U62(isNat(Y), X)) active#(U62(tt, X)) >? mark#(s(length(X))) active#(isNat(s(X))) >? mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) >? mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) >? mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) >? mark#(U61(isNatList(Y), Y, X)) mark#(zeros) >? active#(zeros) mark#(cons(X, Y)) >? mark#(X) mark#(U21(X)) >? mark#(X) mark#(U41(X, Y)) >? active#(U41(mark(X), Y)) mark#(U42(X)) >? mark#(X) mark#(isNatIList(X)) >? active#(isNatIList(X)) mark#(U51(X, Y)) >? active#(U51(mark(X), Y)) mark#(U51(X, Y)) >? mark#(X) mark#(U52(X)) >? mark#(X) mark#(isNatList(X)) >? active#(isNatList(X)) mark#(U61(X, Y, Z)) >? active#(U61(mark(X), Y, Z)) mark#(U61(X, Y, Z)) >? mark#(X) mark#(U62(X, Y)) >? active#(U62(mark(X), Y)) mark#(U62(X, Y)) >? mark#(X) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) mark#(length(X)) >? active#(length(mark(X))) mark#(length(X)) >? mark#(X) active(zeros) >= mark(cons(0, zeros)) active(U21(tt)) >= mark(tt) active(U41(tt, X)) >= mark(U42(isNatIList(X))) active(U42(tt)) >= mark(tt) active(U51(tt, X)) >= mark(U52(isNatList(X))) active(U52(tt)) >= mark(tt) active(U61(tt, X, Y)) >= mark(U62(isNat(Y), X)) active(U62(tt, X)) >= mark(s(length(X))) active(isNat(0)) >= mark(tt) active(isNat(s(X))) >= mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >= mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >= mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >= mark(U61(isNatList(Y), Y, X)) mark(zeros) >= active(zeros) mark(cons(X, Y)) >= active(cons(mark(X), Y)) mark(0) >= active(0) mark(U11(X)) >= active(U11(mark(X))) mark(tt) >= active(tt) mark(U21(X)) >= active(U21(mark(X))) mark(U31(X)) >= active(U31(mark(X))) mark(U41(X, Y)) >= active(U41(mark(X), Y)) mark(U42(X)) >= active(U42(mark(X))) mark(isNatIList(X)) >= active(isNatIList(X)) mark(U51(X, Y)) >= active(U51(mark(X), Y)) mark(U52(X)) >= active(U52(mark(X))) mark(isNatList(X)) >= active(isNatList(X)) mark(U61(X, Y, Z)) >= active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >= active(U62(mark(X), Y)) mark(isNat(X)) >= active(isNat(X)) mark(s(X)) >= active(s(mark(X))) mark(length(X)) >= active(length(mark(X))) mark(nil) >= active(nil) cons(mark(X), Y) >= cons(X, Y) cons(X, mark(Y)) >= cons(X, Y) cons(active(X), Y) >= cons(X, Y) cons(X, active(Y)) >= cons(X, Y) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U41(mark(X), Y) >= U41(X, Y) U41(X, mark(Y)) >= U41(X, Y) U41(active(X), Y) >= U41(X, Y) U41(X, active(Y)) >= U41(X, Y) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) isNatIList(mark(X)) >= isNatIList(X) isNatIList(active(X)) >= isNatIList(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) U61(mark(X), Y, Z) >= U61(X, Y, Z) U61(X, mark(Y), Z) >= U61(X, Y, Z) U61(X, Y, mark(Z)) >= U61(X, Y, Z) U61(active(X), Y, Z) >= U61(X, Y, Z) U61(X, active(Y), Z) >= U61(X, Y, Z) U61(X, Y, active(Z)) >= U61(X, Y, Z) U62(mark(X), Y) >= U62(X, Y) U62(X, mark(Y)) >= U62(X, Y) U62(active(X), Y) >= U62(X, Y) U62(X, active(Y)) >= U62(X, Y) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) length(mark(X)) >= length(X) length(active(X)) >= length(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.0 U21 = \y0.2y0 U31 = \y0.0 U41 = \y0y1.0 U42 = \y0.2y0 U51 = \y0y1.y0 U52 = \y0.y0 U61 = \y0y1y2.1 + y0 + y1 U62 = \y0y1.1 + y0 + y1 active = \y0.y0 active# = \y0.2y0 cons = \y0y1.y1 + 2y0 isNat = \y0.0 isNatIList = \y0.0 isNatList = \y0.0 length = \y0.1 + y0 mark = \y0.y0 mark# = \y0.2y0 nil = 0 s = \y0.y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active#(zeros)]] = 0 >= 0 = [[mark#(cons(0, zeros))]] [[active#(U41(tt, _x0))]] = 0 >= 0 = [[mark#(U42(isNatIList(_x0)))]] [[active#(U51(tt, _x0))]] = 0 >= 0 = [[mark#(U52(isNatList(_x0)))]] [[active#(U61(tt, _x0, _x1))]] = 2 + 2x0 >= 2 + 2x0 = [[mark#(U62(isNat(_x1), _x0))]] [[active#(U62(tt, _x0))]] = 2 + 2x0 >= 2 + 2x0 = [[mark#(s(length(_x0)))]] [[active#(isNat(s(_x0)))]] = 0 >= 0 = [[mark#(U21(isNat(_x0)))]] [[active#(isNatIList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U41(isNat(_x0), _x1))]] [[active#(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U51(isNat(_x0), _x1))]] [[active#(length(cons(_x0, _x1)))]] = 2 + 2x1 + 4x0 >= 2 + 2x1 = [[mark#(U61(isNatList(_x1), _x1, _x0))]] [[mark#(zeros)]] = 0 >= 0 = [[active#(zeros)]] [[mark#(cons(_x0, _x1))]] = 2x1 + 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U21(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U41(_x0, _x1))]] = 0 >= 0 = [[active#(U41(mark(_x0), _x1))]] [[mark#(U42(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatIList(_x0))]] = 0 >= 0 = [[active#(isNatIList(_x0))]] [[mark#(U51(_x0, _x1))]] = 2x0 >= 2x0 = [[active#(U51(mark(_x0), _x1))]] [[mark#(U51(_x0, _x1))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U52(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatList(_x0))]] = 0 >= 0 = [[active#(isNatList(_x0))]] [[mark#(U61(_x0, _x1, _x2))]] = 2 + 2x0 + 2x1 >= 2 + 2x0 + 2x1 = [[active#(U61(mark(_x0), _x1, _x2))]] [[mark#(U61(_x0, _x1, _x2))]] = 2 + 2x0 + 2x1 > 2x0 = [[mark#(_x0)]] [[mark#(U62(_x0, _x1))]] = 2 + 2x0 + 2x1 >= 2 + 2x0 + 2x1 = [[active#(U62(mark(_x0), _x1))]] [[mark#(U62(_x0, _x1))]] = 2 + 2x0 + 2x1 > 2x0 = [[mark#(_x0)]] [[mark#(isNat(_x0))]] = 0 >= 0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(length(_x0))]] = 2 + 2x0 >= 2 + 2x0 = [[active#(length(mark(_x0)))]] [[mark#(length(_x0))]] = 2 + 2x0 > 2x0 = [[mark#(_x0)]] [[active(zeros)]] = 0 >= 0 = [[mark(cons(0, zeros))]] [[active(U21(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U41(tt, _x0))]] = 0 >= 0 = [[mark(U42(isNatIList(_x0)))]] [[active(U42(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U51(tt, _x0))]] = 0 >= 0 = [[mark(U52(isNatList(_x0)))]] [[active(U52(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U61(tt, _x0, _x1))]] = 1 + x0 >= 1 + x0 = [[mark(U62(isNat(_x1), _x0))]] [[active(U62(tt, _x0))]] = 1 + x0 >= 1 + x0 = [[mark(s(length(_x0)))]] [[active(isNat(0))]] = 0 >= 0 = [[mark(tt)]] [[active(isNat(s(_x0)))]] = 0 >= 0 = [[mark(U21(isNat(_x0)))]] [[active(isNatIList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark(U41(isNat(_x0), _x1))]] [[active(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark(U51(isNat(_x0), _x1))]] [[active(length(cons(_x0, _x1)))]] = 1 + x1 + 2x0 >= 1 + x1 = [[mark(U61(isNatList(_x1), _x1, _x0))]] [[mark(zeros)]] = 0 >= 0 = [[active(zeros)]] [[mark(cons(_x0, _x1))]] = x1 + 2x0 >= x1 + 2x0 = [[active(cons(mark(_x0), _x1))]] [[mark(0)]] = 0 >= 0 = [[active(0)]] [[mark(U11(_x0))]] = 0 >= 0 = [[active(U11(mark(_x0)))]] [[mark(tt)]] = 0 >= 0 = [[active(tt)]] [[mark(U21(_x0))]] = 2x0 >= 2x0 = [[active(U21(mark(_x0)))]] [[mark(U31(_x0))]] = 0 >= 0 = [[active(U31(mark(_x0)))]] [[mark(U41(_x0, _x1))]] = 0 >= 0 = [[active(U41(mark(_x0), _x1))]] [[mark(U42(_x0))]] = 2x0 >= 2x0 = [[active(U42(mark(_x0)))]] [[mark(isNatIList(_x0))]] = 0 >= 0 = [[active(isNatIList(_x0))]] [[mark(U51(_x0, _x1))]] = x0 >= x0 = [[active(U51(mark(_x0), _x1))]] [[mark(U52(_x0))]] = x0 >= x0 = [[active(U52(mark(_x0)))]] [[mark(isNatList(_x0))]] = 0 >= 0 = [[active(isNatList(_x0))]] [[mark(U61(_x0, _x1, _x2))]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[active(U61(mark(_x0), _x1, _x2))]] [[mark(U62(_x0, _x1))]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[active(U62(mark(_x0), _x1))]] [[mark(isNat(_x0))]] = 0 >= 0 = [[active(isNat(_x0))]] [[mark(s(_x0))]] = x0 >= x0 = [[active(s(mark(_x0)))]] [[mark(length(_x0))]] = 1 + x0 >= 1 + x0 = [[active(length(mark(_x0)))]] [[mark(nil)]] = 0 >= 0 = [[active(nil)]] [[cons(mark(_x0), _x1)]] = x1 + 2x0 >= x1 + 2x0 = [[cons(_x0, _x1)]] [[cons(_x0, mark(_x1))]] = x1 + 2x0 >= x1 + 2x0 = [[cons(_x0, _x1)]] [[cons(active(_x0), _x1)]] = x1 + 2x0 >= x1 + 2x0 = [[cons(_x0, _x1)]] [[cons(_x0, active(_x1))]] = x1 + 2x0 >= x1 + 2x0 = [[cons(_x0, _x1)]] [[U21(mark(_x0))]] = 2x0 >= 2x0 = [[U21(_x0)]] [[U21(active(_x0))]] = 2x0 >= 2x0 = [[U21(_x0)]] [[U41(mark(_x0), _x1)]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = 2x0 >= 2x0 = [[U42(_x0)]] [[U42(active(_x0))]] = 2x0 >= 2x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = 1 + x0 + x1 >= 1 + x0 + x1 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[s(mark(_x0))]] = x0 >= x0 = [[s(_x0)]] [[s(active(_x0))]] = x0 >= x0 = [[s(_x0)]] [[length(mark(_x0))]] = 1 + x0 >= 1 + x0 = [[length(_x0)]] [[length(active(_x0))]] = 1 + x0 >= 1 + x0 = [[length(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_25, R_2, minimal, formative) by (P_26, R_2, minimal, formative), where P_26 consists of: active#(zeros) =#> mark#(cons(0, zeros)) active#(U41(tt, X)) =#> mark#(U42(isNatIList(X))) active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) =#> mark#(U62(isNat(Y), X)) active#(U62(tt, X)) =#> mark#(s(length(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) =#> mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) =#> mark#(U61(isNatList(Y), Y, X)) mark#(zeros) =#> active#(zeros) mark#(cons(X, Y)) =#> mark#(X) mark#(U21(X)) =#> mark#(X) mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) mark#(U42(X)) =#> mark#(X) mark#(isNatIList(X)) =#> active#(isNatIList(X)) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U51(X, Y)) =#> mark#(X) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(U61(X, Y, Z)) =#> active#(U61(mark(X), Y, Z)) mark#(U62(X, Y)) =#> active#(U62(mark(X), Y)) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) mark#(length(X)) =#> active#(length(mark(X))) Thus, the original system is terminating if (P_26, R_2, minimal, formative) is finite. We consider the dependency pair problem (P_26, R_2, minimal, formative). We will use the reduction pair processor [Kop12, Thm. 7.16]. It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(zeros) >? mark#(cons(0, zeros)) active#(U41(tt, X)) >? mark#(U42(isNatIList(X))) active#(U51(tt, X)) >? mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) >? mark#(U62(isNat(Y), X)) active#(U62(tt, X)) >? mark#(s(length(X))) active#(isNat(s(X))) >? mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) >? mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) >? mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) >? mark#(U61(isNatList(Y), Y, X)) mark#(zeros) >? active#(zeros) mark#(cons(X, Y)) >? mark#(X) mark#(U21(X)) >? mark#(X) mark#(U41(X, Y)) >? active#(U41(mark(X), Y)) mark#(U42(X)) >? mark#(X) mark#(isNatIList(X)) >? active#(isNatIList(X)) mark#(U51(X, Y)) >? active#(U51(mark(X), Y)) mark#(U51(X, Y)) >? mark#(X) mark#(U52(X)) >? mark#(X) mark#(isNatList(X)) >? active#(isNatList(X)) mark#(U61(X, Y, Z)) >? active#(U61(mark(X), Y, Z)) mark#(U62(X, Y)) >? active#(U62(mark(X), Y)) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) mark#(length(X)) >? active#(length(mark(X))) active(zeros) >= mark(cons(0, zeros)) active(U21(tt)) >= mark(tt) active(U41(tt, X)) >= mark(U42(isNatIList(X))) active(U42(tt)) >= mark(tt) active(U51(tt, X)) >= mark(U52(isNatList(X))) active(U52(tt)) >= mark(tt) active(U61(tt, X, Y)) >= mark(U62(isNat(Y), X)) active(U62(tt, X)) >= mark(s(length(X))) active(isNat(0)) >= mark(tt) active(isNat(s(X))) >= mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >= mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >= mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >= mark(U61(isNatList(Y), Y, X)) mark(zeros) >= active(zeros) mark(cons(X, Y)) >= active(cons(mark(X), Y)) mark(0) >= active(0) mark(U11(X)) >= active(U11(mark(X))) mark(tt) >= active(tt) mark(U21(X)) >= active(U21(mark(X))) mark(U31(X)) >= active(U31(mark(X))) mark(U41(X, Y)) >= active(U41(mark(X), Y)) mark(U42(X)) >= active(U42(mark(X))) mark(isNatIList(X)) >= active(isNatIList(X)) mark(U51(X, Y)) >= active(U51(mark(X), Y)) mark(U52(X)) >= active(U52(mark(X))) mark(isNatList(X)) >= active(isNatList(X)) mark(U61(X, Y, Z)) >= active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >= active(U62(mark(X), Y)) mark(isNat(X)) >= active(isNat(X)) mark(s(X)) >= active(s(mark(X))) mark(length(X)) >= active(length(mark(X))) mark(nil) >= active(nil) cons(mark(X), Y) >= cons(X, Y) cons(X, mark(Y)) >= cons(X, Y) cons(active(X), Y) >= cons(X, Y) cons(X, active(Y)) >= cons(X, Y) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U41(mark(X), Y) >= U41(X, Y) U41(X, mark(Y)) >= U41(X, Y) U41(active(X), Y) >= U41(X, Y) U41(X, active(Y)) >= U41(X, Y) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) isNatIList(mark(X)) >= isNatIList(X) isNatIList(active(X)) >= isNatIList(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) U61(mark(X), Y, Z) >= U61(X, Y, Z) U61(X, mark(Y), Z) >= U61(X, Y, Z) U61(X, Y, mark(Z)) >= U61(X, Y, Z) U61(active(X), Y, Z) >= U61(X, Y, Z) U61(X, active(Y), Z) >= U61(X, Y, Z) U61(X, Y, active(Z)) >= U61(X, Y, Z) U62(mark(X), Y) >= U62(X, Y) U62(X, mark(Y)) >= U62(X, Y) U62(active(X), Y) >= U62(X, Y) U62(X, active(Y)) >= U62(X, Y) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) length(mark(X)) >= length(X) length(active(X)) >= length(X) We orient these requirements with a polynomial interpretation in the natural numbers. We consider usable_rules with respect to the following argument filtering: active#(x_1) = active#() This leaves the following ordering requirements: active#(zeros) >= mark#(cons(0, zeros)) active#(U41(tt, X)) >= mark#(U42(isNatIList(X))) active#(U51(tt, X)) >= mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) >= mark#(U62(isNat(Y), X)) active#(U62(tt, X)) >= mark#(s(length(X))) active#(isNat(s(X))) >= mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) >= mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) >= mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) >= mark#(U61(isNatList(Y), Y, X)) mark#(zeros) > active#(zeros) mark#(cons(X, Y)) >= mark#(X) mark#(U21(X)) >= mark#(X) mark#(U41(X, Y)) >= active#(U41(mark(X), Y)) mark#(U42(X)) >= mark#(X) mark#(isNatIList(X)) >= active#(isNatIList(X)) mark#(U51(X, Y)) >= active#(U51(mark(X), Y)) mark#(U51(X, Y)) >= mark#(X) mark#(U52(X)) >= mark#(X) mark#(isNatList(X)) >= active#(isNatList(X)) mark#(U61(X, Y, Z)) >= active#(U61(mark(X), Y, Z)) mark#(U62(X, Y)) >= active#(U62(mark(X), Y)) mark#(isNat(X)) >= active#(isNat(X)) mark#(s(X)) >= mark#(X) mark#(length(X)) >= active#(length(mark(X))) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U41(mark(X), Y) >= U41(X, Y) U41(X, mark(Y)) >= U41(X, Y) U41(active(X), Y) >= U41(X, Y) U41(X, active(Y)) >= U41(X, Y) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) isNatIList(mark(X)) >= isNatIList(X) isNatIList(active(X)) >= isNatIList(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) U61(mark(X), Y, Z) >= U61(X, Y, Z) U61(X, mark(Y), Z) >= U61(X, Y, Z) U61(X, Y, mark(Z)) >= U61(X, Y, Z) U61(active(X), Y, Z) >= U61(X, Y, Z) U61(X, active(Y), Z) >= U61(X, Y, Z) U61(X, Y, active(Z)) >= U61(X, Y, Z) U62(mark(X), Y) >= U62(X, Y) U62(X, mark(Y)) >= U62(X, Y) U62(active(X), Y) >= U62(X, Y) U62(X, active(Y)) >= U62(X, Y) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) length(mark(X)) >= length(X) length(active(X)) >= length(X) The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.0 U21 = \y0.2y0 U31 = \y0.0 U41 = \y0y1.2y0 U42 = \y0.y0 U51 = \y0y1.y0 U52 = \y0.y0 U61 = \y0y1y2.2y0 U62 = \y0y1.0 active = \y0.2y0 active# = \y0.0 cons = \y0y1.y0 isNat = \y0.0 isNatIList = \y0.0 isNatList = \y0.0 length = \y0.0 mark = \y0.2y0 mark# = \y0.2y0 nil = 0 s = \y0.y0 tt = 0 zeros = 2 Using this interpretation, the requirements translate to: [[active#(zeros)]] = 0 >= 0 = [[mark#(cons(0, zeros))]] [[active#(U41(tt, _x0))]] = 0 >= 0 = [[mark#(U42(isNatIList(_x0)))]] [[active#(U51(tt, _x0))]] = 0 >= 0 = [[mark#(U52(isNatList(_x0)))]] [[active#(U61(tt, _x0, _x1))]] = 0 >= 0 = [[mark#(U62(isNat(_x1), _x0))]] [[active#(U62(tt, _x0))]] = 0 >= 0 = [[mark#(s(length(_x0)))]] [[active#(isNat(s(_x0)))]] = 0 >= 0 = [[mark#(U21(isNat(_x0)))]] [[active#(isNatIList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U41(isNat(_x0), _x1))]] [[active#(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U51(isNat(_x0), _x1))]] [[active#(length(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U61(isNatList(_x1), _x1, _x0))]] [[mark#(zeros)]] = 4 > 0 = [[active#(zeros)]] [[mark#(cons(_x0, _x1))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U21(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U41(_x0, _x1))]] = 4x0 >= 0 = [[active#(U41(mark(_x0), _x1))]] [[mark#(U42(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatIList(_x0))]] = 0 >= 0 = [[active#(isNatIList(_x0))]] [[mark#(U51(_x0, _x1))]] = 2x0 >= 0 = [[active#(U51(mark(_x0), _x1))]] [[mark#(U51(_x0, _x1))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U52(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatList(_x0))]] = 0 >= 0 = [[active#(isNatList(_x0))]] [[mark#(U61(_x0, _x1, _x2))]] = 4x0 >= 0 = [[active#(U61(mark(_x0), _x1, _x2))]] [[mark#(U62(_x0, _x1))]] = 0 >= 0 = [[active#(U62(mark(_x0), _x1))]] [[mark#(isNat(_x0))]] = 0 >= 0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(length(_x0))]] = 0 >= 0 = [[active#(length(mark(_x0)))]] [[U21(mark(_x0))]] = 4x0 >= 2x0 = [[U21(_x0)]] [[U21(active(_x0))]] = 4x0 >= 2x0 = [[U21(_x0)]] [[U41(mark(_x0), _x1)]] = 4x0 >= 2x0 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = 2x0 >= 2x0 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = 4x0 >= 2x0 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = 2x0 >= 2x0 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = 2x0 >= x0 = [[U42(_x0)]] [[U42(active(_x0))]] = 2x0 >= x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = 2x0 >= x0 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = 2x0 >= x0 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = x0 >= x0 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = 2x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = 2x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = 4x0 >= 2x0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = 2x0 >= 2x0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = 2x0 >= 2x0 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = 4x0 >= 2x0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = 2x0 >= 2x0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = 2x0 >= 2x0 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = 0 >= 0 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = 0 >= 0 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = 0 >= 0 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = 0 >= 0 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[s(mark(_x0))]] = 2x0 >= x0 = [[s(_x0)]] [[s(active(_x0))]] = 2x0 >= x0 = [[s(_x0)]] [[length(mark(_x0))]] = 0 >= 0 = [[length(_x0)]] [[length(active(_x0))]] = 0 >= 0 = [[length(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_26, R_2, minimal, formative) by (P_27, R_2, minimal, formative), where P_27 consists of: active#(zeros) =#> mark#(cons(0, zeros)) active#(U41(tt, X)) =#> mark#(U42(isNatIList(X))) active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) =#> mark#(U62(isNat(Y), X)) active#(U62(tt, X)) =#> mark#(s(length(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) =#> mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) =#> mark#(U61(isNatList(Y), Y, X)) mark#(cons(X, Y)) =#> mark#(X) mark#(U21(X)) =#> mark#(X) mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) mark#(U42(X)) =#> mark#(X) mark#(isNatIList(X)) =#> active#(isNatIList(X)) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U51(X, Y)) =#> mark#(X) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(U61(X, Y, Z)) =#> active#(U61(mark(X), Y, Z)) mark#(U62(X, Y)) =#> active#(U62(mark(X), Y)) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) mark#(length(X)) =#> active#(length(mark(X))) Thus, the original system is terminating if (P_27, R_2, minimal, formative) is finite. We consider the dependency pair problem (P_27, R_2, minimal, formative). We place the elements of P in a dependency graph approximation G (see e.g. [Kop12, Thm. 7.27, 7.29], as follows: * 0 : 9 * 1 : 12 * 2 : 16 * 3 : 19 * 4 : 21 * 5 : 10 * 6 : 11 * 7 : 14, 15 * 8 : 18 * 9 : 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 * 10 : 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 * 11 : 1 * 12 : 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 * 13 : 6 * 14 : 2 * 15 : 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 * 16 : 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 * 17 : 7 * 18 : 3 * 19 : 4 * 20 : 5 * 21 : 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 * 22 : 8 This graph has the following strongly connected components: P_28: active#(U41(tt, X)) =#> mark#(U42(isNatIList(X))) active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) =#> mark#(U62(isNat(Y), X)) active#(U62(tt, X)) =#> mark#(s(length(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) =#> mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) =#> mark#(U61(isNatList(Y), Y, X)) mark#(cons(X, Y)) =#> mark#(X) mark#(U21(X)) =#> mark#(X) mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) mark#(U42(X)) =#> mark#(X) mark#(isNatIList(X)) =#> active#(isNatIList(X)) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U51(X, Y)) =#> mark#(X) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(U61(X, Y, Z)) =#> active#(U61(mark(X), Y, Z)) mark#(U62(X, Y)) =#> active#(U62(mark(X), Y)) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) mark#(length(X)) =#> active#(length(mark(X))) By [Kop12, Thm. 7.31], we may replace any dependency pair problem (P_27, R_2, m, f) by (P_28, R_2, m, f). Thus, the original system is terminating if (P_28, R_2, minimal, formative) is finite. We consider the dependency pair problem (P_28, R_2, minimal, formative). We will use the reduction pair processor [Kop12, Thm. 7.16]. It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(U41(tt, X)) >? mark#(U42(isNatIList(X))) active#(U51(tt, X)) >? mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) >? mark#(U62(isNat(Y), X)) active#(U62(tt, X)) >? mark#(s(length(X))) active#(isNat(s(X))) >? mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) >? mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) >? mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) >? mark#(U61(isNatList(Y), Y, X)) mark#(cons(X, Y)) >? mark#(X) mark#(U21(X)) >? mark#(X) mark#(U41(X, Y)) >? active#(U41(mark(X), Y)) mark#(U42(X)) >? mark#(X) mark#(isNatIList(X)) >? active#(isNatIList(X)) mark#(U51(X, Y)) >? active#(U51(mark(X), Y)) mark#(U51(X, Y)) >? mark#(X) mark#(U52(X)) >? mark#(X) mark#(isNatList(X)) >? active#(isNatList(X)) mark#(U61(X, Y, Z)) >? active#(U61(mark(X), Y, Z)) mark#(U62(X, Y)) >? active#(U62(mark(X), Y)) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) mark#(length(X)) >? active#(length(mark(X))) active(zeros) >= mark(cons(0, zeros)) active(U21(tt)) >= mark(tt) active(U41(tt, X)) >= mark(U42(isNatIList(X))) active(U42(tt)) >= mark(tt) active(U51(tt, X)) >= mark(U52(isNatList(X))) active(U52(tt)) >= mark(tt) active(U61(tt, X, Y)) >= mark(U62(isNat(Y), X)) active(U62(tt, X)) >= mark(s(length(X))) active(isNat(0)) >= mark(tt) active(isNat(s(X))) >= mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >= mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >= mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >= mark(U61(isNatList(Y), Y, X)) mark(zeros) >= active(zeros) mark(cons(X, Y)) >= active(cons(mark(X), Y)) mark(0) >= active(0) mark(U11(X)) >= active(U11(mark(X))) mark(tt) >= active(tt) mark(U21(X)) >= active(U21(mark(X))) mark(U31(X)) >= active(U31(mark(X))) mark(U41(X, Y)) >= active(U41(mark(X), Y)) mark(U42(X)) >= active(U42(mark(X))) mark(isNatIList(X)) >= active(isNatIList(X)) mark(U51(X, Y)) >= active(U51(mark(X), Y)) mark(U52(X)) >= active(U52(mark(X))) mark(isNatList(X)) >= active(isNatList(X)) mark(U61(X, Y, Z)) >= active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >= active(U62(mark(X), Y)) mark(isNat(X)) >= active(isNat(X)) mark(s(X)) >= active(s(mark(X))) mark(length(X)) >= active(length(mark(X))) mark(nil) >= active(nil) cons(mark(X), Y) >= cons(X, Y) cons(X, mark(Y)) >= cons(X, Y) cons(active(X), Y) >= cons(X, Y) cons(X, active(Y)) >= cons(X, Y) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U41(mark(X), Y) >= U41(X, Y) U41(X, mark(Y)) >= U41(X, Y) U41(active(X), Y) >= U41(X, Y) U41(X, active(Y)) >= U41(X, Y) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) isNatIList(mark(X)) >= isNatIList(X) isNatIList(active(X)) >= isNatIList(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) U61(mark(X), Y, Z) >= U61(X, Y, Z) U61(X, mark(Y), Z) >= U61(X, Y, Z) U61(X, Y, mark(Z)) >= U61(X, Y, Z) U61(active(X), Y, Z) >= U61(X, Y, Z) U61(X, active(Y), Z) >= U61(X, Y, Z) U61(X, Y, active(Z)) >= U61(X, Y, Z) U62(mark(X), Y) >= U62(X, Y) U62(X, mark(Y)) >= U62(X, Y) U62(active(X), Y) >= U62(X, Y) U62(X, active(Y)) >= U62(X, Y) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) length(mark(X)) >= length(X) length(active(X)) >= length(X) We orient these requirements with a polynomial interpretation in the natural numbers. We consider usable_rules with respect to the following argument filtering: active#(x_1) = active#() This leaves the following ordering requirements: active#(U41(tt, X)) >= mark#(U42(isNatIList(X))) active#(U51(tt, X)) >= mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) >= mark#(U62(isNat(Y), X)) active#(U62(tt, X)) >= mark#(s(length(X))) active#(isNat(s(X))) >= mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) >= mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) >= mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) >= mark#(U61(isNatList(Y), Y, X)) mark#(cons(X, Y)) > mark#(X) mark#(U21(X)) >= mark#(X) mark#(U41(X, Y)) >= active#(U41(mark(X), Y)) mark#(U42(X)) >= mark#(X) mark#(isNatIList(X)) >= active#(isNatIList(X)) mark#(U51(X, Y)) >= active#(U51(mark(X), Y)) mark#(U51(X, Y)) >= mark#(X) mark#(U52(X)) >= mark#(X) mark#(isNatList(X)) >= active#(isNatList(X)) mark#(U61(X, Y, Z)) >= active#(U61(mark(X), Y, Z)) mark#(U62(X, Y)) >= active#(U62(mark(X), Y)) mark#(isNat(X)) >= active#(isNat(X)) mark#(s(X)) >= mark#(X) mark#(length(X)) >= active#(length(mark(X))) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U41(mark(X), Y) >= U41(X, Y) U41(X, mark(Y)) >= U41(X, Y) U41(active(X), Y) >= U41(X, Y) U41(X, active(Y)) >= U41(X, Y) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) isNatIList(mark(X)) >= isNatIList(X) isNatIList(active(X)) >= isNatIList(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) U61(mark(X), Y, Z) >= U61(X, Y, Z) U61(X, mark(Y), Z) >= U61(X, Y, Z) U61(X, Y, mark(Z)) >= U61(X, Y, Z) U61(active(X), Y, Z) >= U61(X, Y, Z) U61(X, active(Y), Z) >= U61(X, Y, Z) U61(X, Y, active(Z)) >= U61(X, Y, Z) U62(mark(X), Y) >= U62(X, Y) U62(X, mark(Y)) >= U62(X, Y) U62(active(X), Y) >= U62(X, Y) U62(X, active(Y)) >= U62(X, Y) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) length(mark(X)) >= length(X) length(active(X)) >= length(X) The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.0 U21 = \y0.y0 U31 = \y0.0 U41 = \y0y1.0 U42 = \y0.y0 U51 = \y0y1.2y0 U52 = \y0.y0 U61 = \y0y1y2.0 U62 = \y0y1.0 active = \y0.y0 active# = \y0.0 cons = \y0y1.1 + y0 isNat = \y0.0 isNatIList = \y0.0 isNatList = \y0.0 length = \y0.0 mark = \y0.2y0 mark# = \y0.2y0 nil = 0 s = \y0.y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active#(U41(tt, _x0))]] = 0 >= 0 = [[mark#(U42(isNatIList(_x0)))]] [[active#(U51(tt, _x0))]] = 0 >= 0 = [[mark#(U52(isNatList(_x0)))]] [[active#(U61(tt, _x0, _x1))]] = 0 >= 0 = [[mark#(U62(isNat(_x1), _x0))]] [[active#(U62(tt, _x0))]] = 0 >= 0 = [[mark#(s(length(_x0)))]] [[active#(isNat(s(_x0)))]] = 0 >= 0 = [[mark#(U21(isNat(_x0)))]] [[active#(isNatIList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U41(isNat(_x0), _x1))]] [[active#(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U51(isNat(_x0), _x1))]] [[active#(length(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U61(isNatList(_x1), _x1, _x0))]] [[mark#(cons(_x0, _x1))]] = 2 + 2x0 > 2x0 = [[mark#(_x0)]] [[mark#(U21(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U41(_x0, _x1))]] = 0 >= 0 = [[active#(U41(mark(_x0), _x1))]] [[mark#(U42(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatIList(_x0))]] = 0 >= 0 = [[active#(isNatIList(_x0))]] [[mark#(U51(_x0, _x1))]] = 4x0 >= 0 = [[active#(U51(mark(_x0), _x1))]] [[mark#(U51(_x0, _x1))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U52(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatList(_x0))]] = 0 >= 0 = [[active#(isNatList(_x0))]] [[mark#(U61(_x0, _x1, _x2))]] = 0 >= 0 = [[active#(U61(mark(_x0), _x1, _x2))]] [[mark#(U62(_x0, _x1))]] = 0 >= 0 = [[active#(U62(mark(_x0), _x1))]] [[mark#(isNat(_x0))]] = 0 >= 0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(length(_x0))]] = 0 >= 0 = [[active#(length(mark(_x0)))]] [[U21(mark(_x0))]] = 2x0 >= x0 = [[U21(_x0)]] [[U21(active(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U41(mark(_x0), _x1)]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = 2x0 >= x0 = [[U42(_x0)]] [[U42(active(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = 4x0 >= 2x0 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = 2x0 >= 2x0 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = 2x0 >= 2x0 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = 2x0 >= 2x0 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = 2x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = 0 >= 0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = 0 >= 0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = 0 >= 0 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = 0 >= 0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = 0 >= 0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = 0 >= 0 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = 0 >= 0 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = 0 >= 0 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = 0 >= 0 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = 0 >= 0 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[s(mark(_x0))]] = 2x0 >= x0 = [[s(_x0)]] [[s(active(_x0))]] = x0 >= x0 = [[s(_x0)]] [[length(mark(_x0))]] = 0 >= 0 = [[length(_x0)]] [[length(active(_x0))]] = 0 >= 0 = [[length(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_28, R_2, minimal, formative) by (P_29, R_2, minimal, formative), where P_29 consists of: active#(U41(tt, X)) =#> mark#(U42(isNatIList(X))) active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) =#> mark#(U62(isNat(Y), X)) active#(U62(tt, X)) =#> mark#(s(length(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) =#> mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) =#> mark#(U61(isNatList(Y), Y, X)) mark#(U21(X)) =#> mark#(X) mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) mark#(U42(X)) =#> mark#(X) mark#(isNatIList(X)) =#> active#(isNatIList(X)) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U51(X, Y)) =#> mark#(X) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(U61(X, Y, Z)) =#> active#(U61(mark(X), Y, Z)) mark#(U62(X, Y)) =#> active#(U62(mark(X), Y)) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) mark#(length(X)) =#> active#(length(mark(X))) Thus, the original system is terminating if (P_29, R_2, minimal, formative) is finite. We consider the dependency pair problem (P_29, R_2, minimal, formative). We will use the reduction pair processor [Kop12, Thm. 7.16]. It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(U41(tt, X)) >? mark#(U42(isNatIList(X))) active#(U51(tt, X)) >? mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) >? mark#(U62(isNat(Y), X)) active#(U62(tt, X)) >? mark#(s(length(X))) active#(isNat(s(X))) >? mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) >? mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) >? mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) >? mark#(U61(isNatList(Y), Y, X)) mark#(U21(X)) >? mark#(X) mark#(U41(X, Y)) >? active#(U41(mark(X), Y)) mark#(U42(X)) >? mark#(X) mark#(isNatIList(X)) >? active#(isNatIList(X)) mark#(U51(X, Y)) >? active#(U51(mark(X), Y)) mark#(U51(X, Y)) >? mark#(X) mark#(U52(X)) >? mark#(X) mark#(isNatList(X)) >? active#(isNatList(X)) mark#(U61(X, Y, Z)) >? active#(U61(mark(X), Y, Z)) mark#(U62(X, Y)) >? active#(U62(mark(X), Y)) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) mark#(length(X)) >? active#(length(mark(X))) active(zeros) >= mark(cons(0, zeros)) active(U21(tt)) >= mark(tt) active(U41(tt, X)) >= mark(U42(isNatIList(X))) active(U42(tt)) >= mark(tt) active(U51(tt, X)) >= mark(U52(isNatList(X))) active(U52(tt)) >= mark(tt) active(U61(tt, X, Y)) >= mark(U62(isNat(Y), X)) active(U62(tt, X)) >= mark(s(length(X))) active(isNat(0)) >= mark(tt) active(isNat(s(X))) >= mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >= mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >= mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >= mark(U61(isNatList(Y), Y, X)) mark(zeros) >= active(zeros) mark(cons(X, Y)) >= active(cons(mark(X), Y)) mark(0) >= active(0) mark(U11(X)) >= active(U11(mark(X))) mark(tt) >= active(tt) mark(U21(X)) >= active(U21(mark(X))) mark(U31(X)) >= active(U31(mark(X))) mark(U41(X, Y)) >= active(U41(mark(X), Y)) mark(U42(X)) >= active(U42(mark(X))) mark(isNatIList(X)) >= active(isNatIList(X)) mark(U51(X, Y)) >= active(U51(mark(X), Y)) mark(U52(X)) >= active(U52(mark(X))) mark(isNatList(X)) >= active(isNatList(X)) mark(U61(X, Y, Z)) >= active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >= active(U62(mark(X), Y)) mark(isNat(X)) >= active(isNat(X)) mark(s(X)) >= active(s(mark(X))) mark(length(X)) >= active(length(mark(X))) mark(nil) >= active(nil) cons(mark(X), Y) >= cons(X, Y) cons(X, mark(Y)) >= cons(X, Y) cons(active(X), Y) >= cons(X, Y) cons(X, active(Y)) >= cons(X, Y) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U41(mark(X), Y) >= U41(X, Y) U41(X, mark(Y)) >= U41(X, Y) U41(active(X), Y) >= U41(X, Y) U41(X, active(Y)) >= U41(X, Y) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) isNatIList(mark(X)) >= isNatIList(X) isNatIList(active(X)) >= isNatIList(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) U61(mark(X), Y, Z) >= U61(X, Y, Z) U61(X, mark(Y), Z) >= U61(X, Y, Z) U61(X, Y, mark(Z)) >= U61(X, Y, Z) U61(active(X), Y, Z) >= U61(X, Y, Z) U61(X, active(Y), Z) >= U61(X, Y, Z) U61(X, Y, active(Z)) >= U61(X, Y, Z) U62(mark(X), Y) >= U62(X, Y) U62(X, mark(Y)) >= U62(X, Y) U62(active(X), Y) >= U62(X, Y) U62(X, active(Y)) >= U62(X, Y) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) length(mark(X)) >= length(X) length(active(X)) >= length(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.0 U21 = \y0.y0 U31 = \y0.0 U41 = \y0y1.0 U42 = \y0.2y0 U51 = \y0y1.1 + y0 U52 = \y0.y0 U61 = \y0y1y2.0 U62 = \y0y1.0 active = \y0.y0 active# = \y0.2y0 cons = \y0y1.0 isNat = \y0.0 isNatIList = \y0.0 isNatList = \y0.1 length = \y0.0 mark = \y0.y0 mark# = \y0.2y0 nil = 0 s = \y0.2y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active#(U41(tt, _x0))]] = 0 >= 0 = [[mark#(U42(isNatIList(_x0)))]] [[active#(U51(tt, _x0))]] = 2 >= 2 = [[mark#(U52(isNatList(_x0)))]] [[active#(U61(tt, _x0, _x1))]] = 0 >= 0 = [[mark#(U62(isNat(_x1), _x0))]] [[active#(U62(tt, _x0))]] = 0 >= 0 = [[mark#(s(length(_x0)))]] [[active#(isNat(s(_x0)))]] = 0 >= 0 = [[mark#(U21(isNat(_x0)))]] [[active#(isNatIList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U41(isNat(_x0), _x1))]] [[active#(isNatList(cons(_x0, _x1)))]] = 2 >= 2 = [[mark#(U51(isNat(_x0), _x1))]] [[active#(length(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U61(isNatList(_x1), _x1, _x0))]] [[mark#(U21(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U41(_x0, _x1))]] = 0 >= 0 = [[active#(U41(mark(_x0), _x1))]] [[mark#(U42(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatIList(_x0))]] = 0 >= 0 = [[active#(isNatIList(_x0))]] [[mark#(U51(_x0, _x1))]] = 2 + 2x0 >= 2 + 2x0 = [[active#(U51(mark(_x0), _x1))]] [[mark#(U51(_x0, _x1))]] = 2 + 2x0 > 2x0 = [[mark#(_x0)]] [[mark#(U52(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatList(_x0))]] = 2 >= 2 = [[active#(isNatList(_x0))]] [[mark#(U61(_x0, _x1, _x2))]] = 0 >= 0 = [[active#(U61(mark(_x0), _x1, _x2))]] [[mark#(U62(_x0, _x1))]] = 0 >= 0 = [[active#(U62(mark(_x0), _x1))]] [[mark#(isNat(_x0))]] = 0 >= 0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(length(_x0))]] = 0 >= 0 = [[active#(length(mark(_x0)))]] [[active(zeros)]] = 0 >= 0 = [[mark(cons(0, zeros))]] [[active(U21(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U41(tt, _x0))]] = 0 >= 0 = [[mark(U42(isNatIList(_x0)))]] [[active(U42(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U51(tt, _x0))]] = 1 >= 1 = [[mark(U52(isNatList(_x0)))]] [[active(U52(tt))]] = 0 >= 0 = [[mark(tt)]] [[active(U61(tt, _x0, _x1))]] = 0 >= 0 = [[mark(U62(isNat(_x1), _x0))]] [[active(U62(tt, _x0))]] = 0 >= 0 = [[mark(s(length(_x0)))]] [[active(isNat(0))]] = 0 >= 0 = [[mark(tt)]] [[active(isNat(s(_x0)))]] = 0 >= 0 = [[mark(U21(isNat(_x0)))]] [[active(isNatIList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark(U41(isNat(_x0), _x1))]] [[active(isNatList(cons(_x0, _x1)))]] = 1 >= 1 = [[mark(U51(isNat(_x0), _x1))]] [[active(length(cons(_x0, _x1)))]] = 0 >= 0 = [[mark(U61(isNatList(_x1), _x1, _x0))]] [[mark(zeros)]] = 0 >= 0 = [[active(zeros)]] [[mark(cons(_x0, _x1))]] = 0 >= 0 = [[active(cons(mark(_x0), _x1))]] [[mark(0)]] = 0 >= 0 = [[active(0)]] [[mark(U11(_x0))]] = 0 >= 0 = [[active(U11(mark(_x0)))]] [[mark(tt)]] = 0 >= 0 = [[active(tt)]] [[mark(U21(_x0))]] = x0 >= x0 = [[active(U21(mark(_x0)))]] [[mark(U31(_x0))]] = 0 >= 0 = [[active(U31(mark(_x0)))]] [[mark(U41(_x0, _x1))]] = 0 >= 0 = [[active(U41(mark(_x0), _x1))]] [[mark(U42(_x0))]] = 2x0 >= 2x0 = [[active(U42(mark(_x0)))]] [[mark(isNatIList(_x0))]] = 0 >= 0 = [[active(isNatIList(_x0))]] [[mark(U51(_x0, _x1))]] = 1 + x0 >= 1 + x0 = [[active(U51(mark(_x0), _x1))]] [[mark(U52(_x0))]] = x0 >= x0 = [[active(U52(mark(_x0)))]] [[mark(isNatList(_x0))]] = 1 >= 1 = [[active(isNatList(_x0))]] [[mark(U61(_x0, _x1, _x2))]] = 0 >= 0 = [[active(U61(mark(_x0), _x1, _x2))]] [[mark(U62(_x0, _x1))]] = 0 >= 0 = [[active(U62(mark(_x0), _x1))]] [[mark(isNat(_x0))]] = 0 >= 0 = [[active(isNat(_x0))]] [[mark(s(_x0))]] = 2x0 >= 2x0 = [[active(s(mark(_x0)))]] [[mark(length(_x0))]] = 0 >= 0 = [[active(length(mark(_x0)))]] [[mark(nil)]] = 0 >= 0 = [[active(nil)]] [[cons(mark(_x0), _x1)]] = 0 >= 0 = [[cons(_x0, _x1)]] [[cons(_x0, mark(_x1))]] = 0 >= 0 = [[cons(_x0, _x1)]] [[cons(active(_x0), _x1)]] = 0 >= 0 = [[cons(_x0, _x1)]] [[cons(_x0, active(_x1))]] = 0 >= 0 = [[cons(_x0, _x1)]] [[U21(mark(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U21(active(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[U41(mark(_x0), _x1)]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = 2x0 >= 2x0 = [[U42(_x0)]] [[U42(active(_x0))]] = 2x0 >= 2x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = 1 + x0 >= 1 + x0 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = 1 + x0 >= 1 + x0 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = 1 + x0 >= 1 + x0 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = 1 + x0 >= 1 + x0 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = 1 >= 1 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = 1 >= 1 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = 0 >= 0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = 0 >= 0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = 0 >= 0 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = 0 >= 0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = 0 >= 0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = 0 >= 0 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = 0 >= 0 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = 0 >= 0 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = 0 >= 0 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = 0 >= 0 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[s(mark(_x0))]] = 2x0 >= 2x0 = [[s(_x0)]] [[s(active(_x0))]] = 2x0 >= 2x0 = [[s(_x0)]] [[length(mark(_x0))]] = 0 >= 0 = [[length(_x0)]] [[length(active(_x0))]] = 0 >= 0 = [[length(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_29, R_2, minimal, formative) by (P_30, R_2, minimal, formative), where P_30 consists of: active#(U41(tt, X)) =#> mark#(U42(isNatIList(X))) active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) =#> mark#(U62(isNat(Y), X)) active#(U62(tt, X)) =#> mark#(s(length(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) =#> mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) =#> mark#(U61(isNatList(Y), Y, X)) mark#(U21(X)) =#> mark#(X) mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) mark#(U42(X)) =#> mark#(X) mark#(isNatIList(X)) =#> active#(isNatIList(X)) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(U61(X, Y, Z)) =#> active#(U61(mark(X), Y, Z)) mark#(U62(X, Y)) =#> active#(U62(mark(X), Y)) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) mark#(length(X)) =#> active#(length(mark(X))) Thus, the original system is terminating if (P_30, R_2, minimal, formative) is finite. We consider the dependency pair problem (P_30, R_2, minimal, formative). We will use the reduction pair processor [Kop12, Thm. 7.16]. It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(U41(tt, X)) >? mark#(U42(isNatIList(X))) active#(U51(tt, X)) >? mark#(U52(isNatList(X))) active#(U61(tt, X, Y)) >? mark#(U62(isNat(Y), X)) active#(U62(tt, X)) >? mark#(s(length(X))) active#(isNat(s(X))) >? mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) >? mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) >? mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) >? mark#(U61(isNatList(Y), Y, X)) mark#(U21(X)) >? mark#(X) mark#(U41(X, Y)) >? active#(U41(mark(X), Y)) mark#(U42(X)) >? mark#(X) mark#(isNatIList(X)) >? active#(isNatIList(X)) mark#(U51(X, Y)) >? active#(U51(mark(X), Y)) mark#(U52(X)) >? mark#(X) mark#(isNatList(X)) >? active#(isNatList(X)) mark#(U61(X, Y, Z)) >? active#(U61(mark(X), Y, Z)) mark#(U62(X, Y)) >? active#(U62(mark(X), Y)) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) mark#(length(X)) >? active#(length(mark(X))) active(zeros) >= mark(cons(0, zeros)) active(U21(tt)) >= mark(tt) active(U41(tt, X)) >= mark(U42(isNatIList(X))) active(U42(tt)) >= mark(tt) active(U51(tt, X)) >= mark(U52(isNatList(X))) active(U52(tt)) >= mark(tt) active(U61(tt, X, Y)) >= mark(U62(isNat(Y), X)) active(U62(tt, X)) >= mark(s(length(X))) active(isNat(0)) >= mark(tt) active(isNat(s(X))) >= mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >= mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >= mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >= mark(U61(isNatList(Y), Y, X)) mark(zeros) >= active(zeros) mark(cons(X, Y)) >= active(cons(mark(X), Y)) mark(0) >= active(0) mark(U11(X)) >= active(U11(mark(X))) mark(tt) >= active(tt) mark(U21(X)) >= active(U21(mark(X))) mark(U31(X)) >= active(U31(mark(X))) mark(U41(X, Y)) >= active(U41(mark(X), Y)) mark(U42(X)) >= active(U42(mark(X))) mark(isNatIList(X)) >= active(isNatIList(X)) mark(U51(X, Y)) >= active(U51(mark(X), Y)) mark(U52(X)) >= active(U52(mark(X))) mark(isNatList(X)) >= active(isNatList(X)) mark(U61(X, Y, Z)) >= active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >= active(U62(mark(X), Y)) mark(isNat(X)) >= active(isNat(X)) mark(s(X)) >= active(s(mark(X))) mark(length(X)) >= active(length(mark(X))) mark(nil) >= active(nil) cons(mark(X), Y) >= cons(X, Y) cons(X, mark(Y)) >= cons(X, Y) cons(active(X), Y) >= cons(X, Y) cons(X, active(Y)) >= cons(X, Y) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U41(mark(X), Y) >= U41(X, Y) U41(X, mark(Y)) >= U41(X, Y) U41(active(X), Y) >= U41(X, Y) U41(X, active(Y)) >= U41(X, Y) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) isNatIList(mark(X)) >= isNatIList(X) isNatIList(active(X)) >= isNatIList(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) U61(mark(X), Y, Z) >= U61(X, Y, Z) U61(X, mark(Y), Z) >= U61(X, Y, Z) U61(X, Y, mark(Z)) >= U61(X, Y, Z) U61(active(X), Y, Z) >= U61(X, Y, Z) U61(X, active(Y), Z) >= U61(X, Y, Z) U61(X, Y, active(Z)) >= U61(X, Y, Z) U62(mark(X), Y) >= U62(X, Y) U62(X, mark(Y)) >= U62(X, Y) U62(active(X), Y) >= U62(X, Y) U62(X, active(Y)) >= U62(X, Y) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) length(mark(X)) >= length(X) length(active(X)) >= length(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: 0 = 2 U11 = \y0.0 U21 = \y0.2y0 U31 = \y0.0 U41 = \y0y1.0 U42 = \y0.y0 U51 = \y0y1.0 U52 = \y0.y0 U61 = \y0y1y2.2y0 U62 = \y0y1.1 active = \y0.y0 active# = \y0.y0 cons = \y0y1.0 isNat = \y0.y0 isNatIList = \y0.0 isNatList = \y0.0 length = \y0.0 mark = \y0.y0 mark# = \y0.y0 nil = 0 s = \y0.2y0 tt = 2 zeros = 0 Using this interpretation, the requirements translate to: [[active#(U41(tt, _x0))]] = 0 >= 0 = [[mark#(U42(isNatIList(_x0)))]] [[active#(U51(tt, _x0))]] = 0 >= 0 = [[mark#(U52(isNatList(_x0)))]] [[active#(U61(tt, _x0, _x1))]] = 4 > 1 = [[mark#(U62(isNat(_x1), _x0))]] [[active#(U62(tt, _x0))]] = 1 > 0 = [[mark#(s(length(_x0)))]] [[active#(isNat(s(_x0)))]] = 2x0 >= 2x0 = [[mark#(U21(isNat(_x0)))]] [[active#(isNatIList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U41(isNat(_x0), _x1))]] [[active#(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U51(isNat(_x0), _x1))]] [[active#(length(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U61(isNatList(_x1), _x1, _x0))]] [[mark#(U21(_x0))]] = 2x0 >= x0 = [[mark#(_x0)]] [[mark#(U41(_x0, _x1))]] = 0 >= 0 = [[active#(U41(mark(_x0), _x1))]] [[mark#(U42(_x0))]] = x0 >= x0 = [[mark#(_x0)]] [[mark#(isNatIList(_x0))]] = 0 >= 0 = [[active#(isNatIList(_x0))]] [[mark#(U51(_x0, _x1))]] = 0 >= 0 = [[active#(U51(mark(_x0), _x1))]] [[mark#(U52(_x0))]] = x0 >= x0 = [[mark#(_x0)]] [[mark#(isNatList(_x0))]] = 0 >= 0 = [[active#(isNatList(_x0))]] [[mark#(U61(_x0, _x1, _x2))]] = 2x0 >= 2x0 = [[active#(U61(mark(_x0), _x1, _x2))]] [[mark#(U62(_x0, _x1))]] = 1 >= 1 = [[active#(U62(mark(_x0), _x1))]] [[mark#(isNat(_x0))]] = x0 >= x0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = 2x0 >= x0 = [[mark#(_x0)]] [[mark#(length(_x0))]] = 0 >= 0 = [[active#(length(mark(_x0)))]] [[active(zeros)]] = 0 >= 0 = [[mark(cons(0, zeros))]] [[active(U21(tt))]] = 4 >= 2 = [[mark(tt)]] [[active(U41(tt, _x0))]] = 0 >= 0 = [[mark(U42(isNatIList(_x0)))]] [[active(U42(tt))]] = 2 >= 2 = [[mark(tt)]] [[active(U51(tt, _x0))]] = 0 >= 0 = [[mark(U52(isNatList(_x0)))]] [[active(U52(tt))]] = 2 >= 2 = [[mark(tt)]] [[active(U61(tt, _x0, _x1))]] = 4 >= 1 = [[mark(U62(isNat(_x1), _x0))]] [[active(U62(tt, _x0))]] = 1 >= 0 = [[mark(s(length(_x0)))]] [[active(isNat(0))]] = 2 >= 2 = [[mark(tt)]] [[active(isNat(s(_x0)))]] = 2x0 >= 2x0 = [[mark(U21(isNat(_x0)))]] [[active(isNatIList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark(U41(isNat(_x0), _x1))]] [[active(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark(U51(isNat(_x0), _x1))]] [[active(length(cons(_x0, _x1)))]] = 0 >= 0 = [[mark(U61(isNatList(_x1), _x1, _x0))]] [[mark(zeros)]] = 0 >= 0 = [[active(zeros)]] [[mark(cons(_x0, _x1))]] = 0 >= 0 = [[active(cons(mark(_x0), _x1))]] [[mark(0)]] = 2 >= 2 = [[active(0)]] [[mark(U11(_x0))]] = 0 >= 0 = [[active(U11(mark(_x0)))]] [[mark(tt)]] = 2 >= 2 = [[active(tt)]] [[mark(U21(_x0))]] = 2x0 >= 2x0 = [[active(U21(mark(_x0)))]] [[mark(U31(_x0))]] = 0 >= 0 = [[active(U31(mark(_x0)))]] [[mark(U41(_x0, _x1))]] = 0 >= 0 = [[active(U41(mark(_x0), _x1))]] [[mark(U42(_x0))]] = x0 >= x0 = [[active(U42(mark(_x0)))]] [[mark(isNatIList(_x0))]] = 0 >= 0 = [[active(isNatIList(_x0))]] [[mark(U51(_x0, _x1))]] = 0 >= 0 = [[active(U51(mark(_x0), _x1))]] [[mark(U52(_x0))]] = x0 >= x0 = [[active(U52(mark(_x0)))]] [[mark(isNatList(_x0))]] = 0 >= 0 = [[active(isNatList(_x0))]] [[mark(U61(_x0, _x1, _x2))]] = 2x0 >= 2x0 = [[active(U61(mark(_x0), _x1, _x2))]] [[mark(U62(_x0, _x1))]] = 1 >= 1 = [[active(U62(mark(_x0), _x1))]] [[mark(isNat(_x0))]] = x0 >= x0 = [[active(isNat(_x0))]] [[mark(s(_x0))]] = 2x0 >= 2x0 = [[active(s(mark(_x0)))]] [[mark(length(_x0))]] = 0 >= 0 = [[active(length(mark(_x0)))]] [[mark(nil)]] = 0 >= 0 = [[active(nil)]] [[cons(mark(_x0), _x1)]] = 0 >= 0 = [[cons(_x0, _x1)]] [[cons(_x0, mark(_x1))]] = 0 >= 0 = [[cons(_x0, _x1)]] [[cons(active(_x0), _x1)]] = 0 >= 0 = [[cons(_x0, _x1)]] [[cons(_x0, active(_x1))]] = 0 >= 0 = [[cons(_x0, _x1)]] [[U21(mark(_x0))]] = 2x0 >= 2x0 = [[U21(_x0)]] [[U21(active(_x0))]] = 2x0 >= 2x0 = [[U21(_x0)]] [[U41(mark(_x0), _x1)]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = 0 >= 0 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[U42(active(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = 0 >= 0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = 0 >= 0 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = 0 >= 0 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = 0 >= 0 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = 0 >= 0 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[U61(mark(_x0), _x1, _x2)]] = 2x0 >= 2x0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, mark(_x1), _x2)]] = 2x0 >= 2x0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, mark(_x2))]] = 2x0 >= 2x0 = [[U61(_x0, _x1, _x2)]] [[U61(active(_x0), _x1, _x2)]] = 2x0 >= 2x0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, active(_x1), _x2)]] = 2x0 >= 2x0 = [[U61(_x0, _x1, _x2)]] [[U61(_x0, _x1, active(_x2))]] = 2x0 >= 2x0 = [[U61(_x0, _x1, _x2)]] [[U62(mark(_x0), _x1)]] = 1 >= 1 = [[U62(_x0, _x1)]] [[U62(_x0, mark(_x1))]] = 1 >= 1 = [[U62(_x0, _x1)]] [[U62(active(_x0), _x1)]] = 1 >= 1 = [[U62(_x0, _x1)]] [[U62(_x0, active(_x1))]] = 1 >= 1 = [[U62(_x0, _x1)]] [[isNat(mark(_x0))]] = x0 >= x0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = x0 >= x0 = [[isNat(_x0)]] [[s(mark(_x0))]] = 2x0 >= 2x0 = [[s(_x0)]] [[s(active(_x0))]] = 2x0 >= 2x0 = [[s(_x0)]] [[length(mark(_x0))]] = 0 >= 0 = [[length(_x0)]] [[length(active(_x0))]] = 0 >= 0 = [[length(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_30, R_2, minimal, formative) by (P_31, R_2, minimal, formative), where P_31 consists of: active#(U41(tt, X)) =#> mark#(U42(isNatIList(X))) active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) =#> mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) active#(length(cons(X, Y))) =#> mark#(U61(isNatList(Y), Y, X)) mark#(U21(X)) =#> mark#(X) mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) mark#(U42(X)) =#> mark#(X) mark#(isNatIList(X)) =#> active#(isNatIList(X)) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(U61(X, Y, Z)) =#> active#(U61(mark(X), Y, Z)) mark#(U62(X, Y)) =#> active#(U62(mark(X), Y)) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) mark#(length(X)) =#> active#(length(mark(X))) Thus, the original system is terminating if (P_31, R_2, minimal, formative) is finite. We consider the dependency pair problem (P_31, R_2, minimal, formative). We place the elements of P in a dependency graph approximation G (see e.g. [Kop12, Thm. 7.27, 7.29], as follows: * 0 : 8 * 1 : 11 * 2 : 6 * 3 : 7 * 4 : 10 * 5 : 13 * 6 : 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 * 7 : 0 * 8 : 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 * 9 : 3 * 10 : 1 * 11 : 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 * 12 : 4 * 13 : * 14 : * 15 : 2 * 16 : 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 * 17 : 5 This graph has the following strongly connected components: P_32: active#(U41(tt, X)) =#> mark#(U42(isNatIList(X))) active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) =#> mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) mark#(U21(X)) =#> mark#(X) mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) mark#(U42(X)) =#> mark#(X) mark#(isNatIList(X)) =#> active#(isNatIList(X)) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) By [Kop12, Thm. 7.31], we may replace any dependency pair problem (P_31, R_2, m, f) by (P_32, R_2, m, f). Thus, the original system is terminating if (P_32, R_2, minimal, formative) is finite. We consider the dependency pair problem (P_32, R_2, minimal, formative). The formative rules of (P_32, R_2) are R_3 ::= active(zeros) => mark(cons(0, zeros)) active(U21(tt)) => mark(tt) active(U41(tt, X)) => mark(U42(isNatIList(X))) active(U42(tt)) => mark(tt) active(U51(tt, X)) => mark(U52(isNatList(X))) active(U52(tt)) => mark(tt) active(U61(tt, X, Y)) => mark(U62(isNat(Y), X)) active(U62(tt, X)) => mark(s(length(X))) active(isNat(0)) => mark(tt) active(isNat(s(X))) => mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) => mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) => mark(U51(isNat(X), Y)) active(length(cons(X, Y))) => mark(U61(isNatList(Y), Y, X)) mark(zeros) => active(zeros) mark(cons(X, Y)) => active(cons(mark(X), Y)) mark(0) => active(0) mark(U11(X)) => active(U11(mark(X))) mark(tt) => active(tt) mark(U21(X)) => active(U21(mark(X))) mark(U31(X)) => active(U31(mark(X))) mark(U41(X, Y)) => active(U41(mark(X), Y)) mark(U42(X)) => active(U42(mark(X))) mark(isNatIList(X)) => active(isNatIList(X)) mark(U51(X, Y)) => active(U51(mark(X), Y)) mark(U52(X)) => active(U52(mark(X))) mark(isNatList(X)) => active(isNatList(X)) mark(U61(X, Y, Z)) => active(U61(mark(X), Y, Z)) mark(U62(X, Y)) => active(U62(mark(X), Y)) mark(isNat(X)) => active(isNat(X)) mark(s(X)) => active(s(mark(X))) mark(length(X)) => active(length(mark(X))) mark(nil) => active(nil) cons(mark(X), Y) => cons(X, Y) cons(X, mark(Y)) => cons(X, Y) cons(active(X), Y) => cons(X, Y) cons(X, active(Y)) => cons(X, Y) U21(mark(X)) => U21(X) U21(active(X)) => U21(X) U41(mark(X), Y) => U41(X, Y) U41(X, mark(Y)) => U41(X, Y) U41(active(X), Y) => U41(X, Y) U41(X, active(Y)) => U41(X, Y) U42(mark(X)) => U42(X) U42(active(X)) => U42(X) isNatIList(mark(X)) => isNatIList(X) isNatIList(active(X)) => isNatIList(X) U51(mark(X), Y) => U51(X, Y) U51(X, mark(Y)) => U51(X, Y) U51(active(X), Y) => U51(X, Y) U51(X, active(Y)) => U51(X, Y) U52(mark(X)) => U52(X) U52(active(X)) => U52(X) isNatList(mark(X)) => isNatList(X) isNatList(active(X)) => isNatList(X) isNat(mark(X)) => isNat(X) isNat(active(X)) => isNat(X) s(mark(X)) => s(X) s(active(X)) => s(X) By [Kop12, Thm. 7.17], we may replace the dependency pair problem (P_32, R_2, minimal, formative) by (P_32, R_3, minimal, formative). Thus, the original system is terminating if (P_32, R_3, minimal, formative) is finite. We consider the dependency pair problem (P_32, R_3, minimal, formative). We will use the reduction pair processor [Kop12, Thm. 7.16]. It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(U41(tt, X)) >? mark#(U42(isNatIList(X))) active#(U51(tt, X)) >? mark#(U52(isNatList(X))) active#(isNat(s(X))) >? mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) >? mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) >? mark#(U51(isNat(X), Y)) mark#(U21(X)) >? mark#(X) mark#(U41(X, Y)) >? active#(U41(mark(X), Y)) mark#(U42(X)) >? mark#(X) mark#(isNatIList(X)) >? active#(isNatIList(X)) mark#(U51(X, Y)) >? active#(U51(mark(X), Y)) mark#(U52(X)) >? mark#(X) mark#(isNatList(X)) >? active#(isNatList(X)) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) active(zeros) >= mark(cons(0, zeros)) active(U21(tt)) >= mark(tt) active(U41(tt, X)) >= mark(U42(isNatIList(X))) active(U42(tt)) >= mark(tt) active(U51(tt, X)) >= mark(U52(isNatList(X))) active(U52(tt)) >= mark(tt) active(U61(tt, X, Y)) >= mark(U62(isNat(Y), X)) active(U62(tt, X)) >= mark(s(length(X))) active(isNat(0)) >= mark(tt) active(isNat(s(X))) >= mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >= mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >= mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >= mark(U61(isNatList(Y), Y, X)) mark(zeros) >= active(zeros) mark(cons(X, Y)) >= active(cons(mark(X), Y)) mark(0) >= active(0) mark(U11(X)) >= active(U11(mark(X))) mark(tt) >= active(tt) mark(U21(X)) >= active(U21(mark(X))) mark(U31(X)) >= active(U31(mark(X))) mark(U41(X, Y)) >= active(U41(mark(X), Y)) mark(U42(X)) >= active(U42(mark(X))) mark(isNatIList(X)) >= active(isNatIList(X)) mark(U51(X, Y)) >= active(U51(mark(X), Y)) mark(U52(X)) >= active(U52(mark(X))) mark(isNatList(X)) >= active(isNatList(X)) mark(U61(X, Y, Z)) >= active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >= active(U62(mark(X), Y)) mark(isNat(X)) >= active(isNat(X)) mark(s(X)) >= active(s(mark(X))) mark(length(X)) >= active(length(mark(X))) mark(nil) >= active(nil) cons(mark(X), Y) >= cons(X, Y) cons(X, mark(Y)) >= cons(X, Y) cons(active(X), Y) >= cons(X, Y) cons(X, active(Y)) >= cons(X, Y) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U41(mark(X), Y) >= U41(X, Y) U41(X, mark(Y)) >= U41(X, Y) U41(active(X), Y) >= U41(X, Y) U41(X, active(Y)) >= U41(X, Y) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) isNatIList(mark(X)) >= isNatIList(X) isNatIList(active(X)) >= isNatIList(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) We orient these requirements with a polynomial interpretation in the natural numbers. We consider usable_rules with respect to the following argument filtering: U41(x_1,x_2) = U41(x_2) U51(x_1,x_2) = U51(x_2) This leaves the following ordering requirements: active#(U41(tt, X)) > mark#(U42(isNatIList(X))) active#(U51(tt, X)) >= mark#(U52(isNatList(X))) active#(isNat(s(X))) >= mark#(U21(isNat(X))) active#(isNatIList(cons(X, Y))) > mark#(U41(isNat(X), Y)) active#(isNatList(cons(X, Y))) >= mark#(U51(isNat(X), Y)) mark#(U21(X)) >= mark#(X) mark#(U41(X, Y)) >= active#(U41(mark(X), Y)) mark#(U42(X)) >= mark#(X) mark#(isNatIList(X)) >= active#(isNatIList(X)) mark#(U51(X, Y)) >= active#(U51(mark(X), Y)) mark#(U52(X)) >= mark#(X) mark#(isNatList(X)) >= active#(isNatList(X)) mark#(isNat(X)) >= active#(isNat(X)) mark#(s(X)) >= mark#(X) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U41(mark(X), Y) >= U41(X, Y) U41(X, mark(Y)) >= U41(X, Y) U41(active(X), Y) >= U41(X, Y) U41(X, active(Y)) >= U41(X, Y) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) isNatIList(mark(X)) >= isNatIList(X) isNatIList(active(X)) >= isNatIList(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.0 U21 = \y0.2y0 U31 = \y0.0 U41 = \y0y1.1 + y1 U42 = \y0.y0 U51 = \y0y1.0 U52 = \y0.2y0 U61 = \y0y1y2.0 U62 = \y0y1.0 active = \y0.y0 active# = \y0.2y0 cons = \y0y1.2 + y1 isNat = \y0.0 isNatIList = \y0.y0 isNatList = \y0.0 length = \y0.0 mark = \y0.y0 mark# = \y0.2y0 nil = 0 s = \y0.y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active#(U41(tt, _x0))]] = 2 + 2x0 > 2x0 = [[mark#(U42(isNatIList(_x0)))]] [[active#(U51(tt, _x0))]] = 0 >= 0 = [[mark#(U52(isNatList(_x0)))]] [[active#(isNat(s(_x0)))]] = 0 >= 0 = [[mark#(U21(isNat(_x0)))]] [[active#(isNatIList(cons(_x0, _x1)))]] = 4 + 2x1 > 2 + 2x1 = [[mark#(U41(isNat(_x0), _x1))]] [[active#(isNatList(cons(_x0, _x1)))]] = 0 >= 0 = [[mark#(U51(isNat(_x0), _x1))]] [[mark#(U21(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U41(_x0, _x1))]] = 2 + 2x1 >= 2 + 2x1 = [[active#(U41(mark(_x0), _x1))]] [[mark#(U42(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatIList(_x0))]] = 2x0 >= 2x0 = [[active#(isNatIList(_x0))]] [[mark#(U51(_x0, _x1))]] = 0 >= 0 = [[active#(U51(mark(_x0), _x1))]] [[mark#(U52(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatList(_x0))]] = 0 >= 0 = [[active#(isNatList(_x0))]] [[mark#(isNat(_x0))]] = 0 >= 0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[U21(mark(_x0))]] = 2x0 >= 2x0 = [[U21(_x0)]] [[U21(active(_x0))]] = 2x0 >= 2x0 = [[U21(_x0)]] [[U41(mark(_x0), _x1)]] = 1 + x1 >= 1 + x1 = [[U41(_x0, _x1)]] [[U41(_x0, mark(_x1))]] = 1 + x1 >= 1 + x1 = [[U41(_x0, _x1)]] [[U41(active(_x0), _x1)]] = 1 + x1 >= 1 + x1 = [[U41(_x0, _x1)]] [[U41(_x0, active(_x1))]] = 1 + x1 >= 1 + x1 = [[U41(_x0, _x1)]] [[U42(mark(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[U42(active(_x0))]] = x0 >= x0 = [[U42(_x0)]] [[isNatIList(mark(_x0))]] = x0 >= x0 = [[isNatIList(_x0)]] [[isNatIList(active(_x0))]] = x0 >= x0 = [[isNatIList(_x0)]] [[U51(mark(_x0), _x1)]] = 0 >= 0 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = 0 >= 0 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = 0 >= 0 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = 0 >= 0 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = 2x0 >= 2x0 = [[U52(_x0)]] [[U52(active(_x0))]] = 2x0 >= 2x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = 0 >= 0 = [[isNatList(_x0)]] [[isNat(mark(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 0 >= 0 = [[isNat(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_32, R_3, minimal, formative) by (P_33, R_3, minimal, formative), where P_33 consists of: active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) mark#(U21(X)) =#> mark#(X) mark#(U41(X, Y)) =#> active#(U41(mark(X), Y)) mark#(U42(X)) =#> mark#(X) mark#(isNatIList(X)) =#> active#(isNatIList(X)) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) Thus, the original system is terminating if (P_33, R_3, minimal, formative) is finite. We consider the dependency pair problem (P_33, R_3, minimal, formative). We place the elements of P in a dependency graph approximation G (see e.g. [Kop12, Thm. 7.27, 7.29], as follows: * 0 : 8 * 1 : 3 * 2 : 7 * 3 : 3, 4, 5, 6, 7, 8, 9, 10, 11 * 4 : * 5 : 3, 4, 5, 6, 7, 8, 9, 10, 11 * 6 : * 7 : 0 * 8 : 3, 4, 5, 6, 7, 8, 9, 10, 11 * 9 : 2 * 10 : 1 * 11 : 3, 4, 5, 6, 7, 8, 9, 10, 11 This graph has the following strongly connected components: P_34: active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) active#(isNatList(cons(X, Y))) =#> mark#(U51(isNat(X), Y)) mark#(U21(X)) =#> mark#(X) mark#(U42(X)) =#> mark#(X) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) By [Kop12, Thm. 7.31], we may replace any dependency pair problem (P_33, R_3, m, f) by (P_34, R_3, m, f). Thus, the original system is terminating if (P_34, R_3, minimal, formative) is finite. We consider the dependency pair problem (P_34, R_3, minimal, formative). The formative rules of (P_34, R_3) are R_4 ::= active(zeros) => mark(cons(0, zeros)) active(U21(tt)) => mark(tt) active(U41(tt, X)) => mark(U42(isNatIList(X))) active(U42(tt)) => mark(tt) active(U51(tt, X)) => mark(U52(isNatList(X))) active(U52(tt)) => mark(tt) active(U61(tt, X, Y)) => mark(U62(isNat(Y), X)) active(U62(tt, X)) => mark(s(length(X))) active(isNat(0)) => mark(tt) active(isNat(s(X))) => mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) => mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) => mark(U51(isNat(X), Y)) active(length(cons(X, Y))) => mark(U61(isNatList(Y), Y, X)) mark(zeros) => active(zeros) mark(cons(X, Y)) => active(cons(mark(X), Y)) mark(0) => active(0) mark(U11(X)) => active(U11(mark(X))) mark(tt) => active(tt) mark(U21(X)) => active(U21(mark(X))) mark(U31(X)) => active(U31(mark(X))) mark(U41(X, Y)) => active(U41(mark(X), Y)) mark(U42(X)) => active(U42(mark(X))) mark(isNatIList(X)) => active(isNatIList(X)) mark(U51(X, Y)) => active(U51(mark(X), Y)) mark(U52(X)) => active(U52(mark(X))) mark(isNatList(X)) => active(isNatList(X)) mark(U61(X, Y, Z)) => active(U61(mark(X), Y, Z)) mark(U62(X, Y)) => active(U62(mark(X), Y)) mark(isNat(X)) => active(isNat(X)) mark(s(X)) => active(s(mark(X))) mark(length(X)) => active(length(mark(X))) mark(nil) => active(nil) cons(mark(X), Y) => cons(X, Y) cons(X, mark(Y)) => cons(X, Y) cons(active(X), Y) => cons(X, Y) cons(X, active(Y)) => cons(X, Y) U21(mark(X)) => U21(X) U21(active(X)) => U21(X) U42(mark(X)) => U42(X) U42(active(X)) => U42(X) U51(mark(X), Y) => U51(X, Y) U51(X, mark(Y)) => U51(X, Y) U51(active(X), Y) => U51(X, Y) U51(X, active(Y)) => U51(X, Y) U52(mark(X)) => U52(X) U52(active(X)) => U52(X) isNatList(mark(X)) => isNatList(X) isNatList(active(X)) => isNatList(X) isNat(mark(X)) => isNat(X) isNat(active(X)) => isNat(X) s(mark(X)) => s(X) s(active(X)) => s(X) By [Kop12, Thm. 7.17], we may replace the dependency pair problem (P_34, R_3, minimal, formative) by (P_34, R_4, minimal, formative). Thus, the original system is terminating if (P_34, R_4, minimal, formative) is finite. We consider the dependency pair problem (P_34, R_4, minimal, formative). We will use the reduction pair processor [Kop12, Thm. 7.16]. It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(U51(tt, X)) >? mark#(U52(isNatList(X))) active#(isNat(s(X))) >? mark#(U21(isNat(X))) active#(isNatList(cons(X, Y))) >? mark#(U51(isNat(X), Y)) mark#(U21(X)) >? mark#(X) mark#(U42(X)) >? mark#(X) mark#(U51(X, Y)) >? active#(U51(mark(X), Y)) mark#(U52(X)) >? mark#(X) mark#(isNatList(X)) >? active#(isNatList(X)) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) active(zeros) >= mark(cons(0, zeros)) active(U21(tt)) >= mark(tt) active(U41(tt, X)) >= mark(U42(isNatIList(X))) active(U42(tt)) >= mark(tt) active(U51(tt, X)) >= mark(U52(isNatList(X))) active(U52(tt)) >= mark(tt) active(U61(tt, X, Y)) >= mark(U62(isNat(Y), X)) active(U62(tt, X)) >= mark(s(length(X))) active(isNat(0)) >= mark(tt) active(isNat(s(X))) >= mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >= mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >= mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >= mark(U61(isNatList(Y), Y, X)) mark(zeros) >= active(zeros) mark(cons(X, Y)) >= active(cons(mark(X), Y)) mark(0) >= active(0) mark(U11(X)) >= active(U11(mark(X))) mark(tt) >= active(tt) mark(U21(X)) >= active(U21(mark(X))) mark(U31(X)) >= active(U31(mark(X))) mark(U41(X, Y)) >= active(U41(mark(X), Y)) mark(U42(X)) >= active(U42(mark(X))) mark(isNatIList(X)) >= active(isNatIList(X)) mark(U51(X, Y)) >= active(U51(mark(X), Y)) mark(U52(X)) >= active(U52(mark(X))) mark(isNatList(X)) >= active(isNatList(X)) mark(U61(X, Y, Z)) >= active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >= active(U62(mark(X), Y)) mark(isNat(X)) >= active(isNat(X)) mark(s(X)) >= active(s(mark(X))) mark(length(X)) >= active(length(mark(X))) mark(nil) >= active(nil) cons(mark(X), Y) >= cons(X, Y) cons(X, mark(Y)) >= cons(X, Y) cons(active(X), Y) >= cons(X, Y) cons(X, active(Y)) >= cons(X, Y) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) We orient these requirements with a polynomial interpretation in the natural numbers. We consider usable_rules with respect to the following argument filtering: U51(x_1,x_2) = U51(x_2) This leaves the following ordering requirements: active#(U51(tt, X)) >= mark#(U52(isNatList(X))) active#(isNat(s(X))) >= mark#(U21(isNat(X))) active#(isNatList(cons(X, Y))) > mark#(U51(isNat(X), Y)) mark#(U21(X)) >= mark#(X) mark#(U42(X)) >= mark#(X) mark#(U51(X, Y)) >= active#(U51(mark(X), Y)) mark#(U52(X)) >= mark#(X) mark#(isNatList(X)) >= active#(isNatList(X)) mark#(isNat(X)) >= active#(isNat(X)) mark#(s(X)) >= mark#(X) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNatList(mark(X)) >= isNatList(X) isNatList(active(X)) >= isNatList(X) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.0 U21 = \y0.2y0 U31 = \y0.0 U41 = \y0y1.0 U42 = \y0.2y0 U51 = \y0y1.2y1 U52 = \y0.y0 U61 = \y0y1y2.0 U62 = \y0y1.0 active = \y0.2y0 active# = \y0.2y0 cons = \y0y1.2 + 2y1 isNat = \y0.0 isNatIList = \y0.0 isNatList = \y0.2y0 length = \y0.0 mark = \y0.y0 mark# = \y0.2y0 nil = 0 s = \y0.y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active#(U51(tt, _x0))]] = 4x0 >= 4x0 = [[mark#(U52(isNatList(_x0)))]] [[active#(isNat(s(_x0)))]] = 0 >= 0 = [[mark#(U21(isNat(_x0)))]] [[active#(isNatList(cons(_x0, _x1)))]] = 8 + 8x1 > 4x1 = [[mark#(U51(isNat(_x0), _x1))]] [[mark#(U21(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U42(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U51(_x0, _x1))]] = 4x1 >= 4x1 = [[active#(U51(mark(_x0), _x1))]] [[mark#(U52(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNatList(_x0))]] = 4x0 >= 4x0 = [[active#(isNatList(_x0))]] [[mark#(isNat(_x0))]] = 0 >= 0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[U21(mark(_x0))]] = 2x0 >= 2x0 = [[U21(_x0)]] [[U21(active(_x0))]] = 4x0 >= 2x0 = [[U21(_x0)]] [[U51(mark(_x0), _x1)]] = 2x1 >= 2x1 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = 2x1 >= 2x1 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = 2x1 >= 2x1 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = 4x1 >= 2x1 = [[U51(_x0, _x1)]] [[U52(mark(_x0))]] = x0 >= x0 = [[U52(_x0)]] [[U52(active(_x0))]] = 2x0 >= x0 = [[U52(_x0)]] [[isNatList(mark(_x0))]] = 2x0 >= 2x0 = [[isNatList(_x0)]] [[isNatList(active(_x0))]] = 4x0 >= 2x0 = [[isNatList(_x0)]] [[isNat(mark(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 0 >= 0 = [[isNat(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_34, R_4, minimal, formative) by (P_35, R_4, minimal, formative), where P_35 consists of: active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) mark#(U21(X)) =#> mark#(X) mark#(U42(X)) =#> mark#(X) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U52(X)) =#> mark#(X) mark#(isNatList(X)) =#> active#(isNatList(X)) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) Thus, the original system is terminating if (P_35, R_4, minimal, formative) is finite. We consider the dependency pair problem (P_35, R_4, minimal, formative). We place the elements of P in a dependency graph approximation G (see e.g. [Kop12, Thm. 7.27, 7.29], as follows: * 0 : 5 * 1 : 2 * 2 : 2, 3, 4, 5, 6, 7, 8 * 3 : 2, 3, 4, 5, 6, 7, 8 * 4 : 0 * 5 : 2, 3, 4, 5, 6, 7, 8 * 6 : * 7 : 1 * 8 : 2, 3, 4, 5, 6, 7, 8 This graph has the following strongly connected components: P_36: active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) mark#(U21(X)) =#> mark#(X) mark#(U42(X)) =#> mark#(X) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U52(X)) =#> mark#(X) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) By [Kop12, Thm. 7.31], we may replace any dependency pair problem (P_35, R_4, m, f) by (P_36, R_4, m, f). Thus, the original system is terminating if (P_36, R_4, minimal, formative) is finite. We consider the dependency pair problem (P_36, R_4, minimal, formative). The formative rules of (P_36, R_4) are R_5 ::= active(zeros) => mark(cons(0, zeros)) active(U21(tt)) => mark(tt) active(U41(tt, X)) => mark(U42(isNatIList(X))) active(U42(tt)) => mark(tt) active(U51(tt, X)) => mark(U52(isNatList(X))) active(U52(tt)) => mark(tt) active(U61(tt, X, Y)) => mark(U62(isNat(Y), X)) active(U62(tt, X)) => mark(s(length(X))) active(isNat(0)) => mark(tt) active(isNat(s(X))) => mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) => mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) => mark(U51(isNat(X), Y)) active(length(cons(X, Y))) => mark(U61(isNatList(Y), Y, X)) mark(zeros) => active(zeros) mark(cons(X, Y)) => active(cons(mark(X), Y)) mark(0) => active(0) mark(U11(X)) => active(U11(mark(X))) mark(tt) => active(tt) mark(U21(X)) => active(U21(mark(X))) mark(U31(X)) => active(U31(mark(X))) mark(U41(X, Y)) => active(U41(mark(X), Y)) mark(U42(X)) => active(U42(mark(X))) mark(isNatIList(X)) => active(isNatIList(X)) mark(U51(X, Y)) => active(U51(mark(X), Y)) mark(U52(X)) => active(U52(mark(X))) mark(isNatList(X)) => active(isNatList(X)) mark(U61(X, Y, Z)) => active(U61(mark(X), Y, Z)) mark(U62(X, Y)) => active(U62(mark(X), Y)) mark(isNat(X)) => active(isNat(X)) mark(s(X)) => active(s(mark(X))) mark(length(X)) => active(length(mark(X))) mark(nil) => active(nil) U21(mark(X)) => U21(X) U21(active(X)) => U21(X) U42(mark(X)) => U42(X) U42(active(X)) => U42(X) U51(mark(X), Y) => U51(X, Y) U51(X, mark(Y)) => U51(X, Y) U51(active(X), Y) => U51(X, Y) U51(X, active(Y)) => U51(X, Y) U52(mark(X)) => U52(X) U52(active(X)) => U52(X) isNat(mark(X)) => isNat(X) isNat(active(X)) => isNat(X) s(mark(X)) => s(X) s(active(X)) => s(X) By [Kop12, Thm. 7.17], we may replace the dependency pair problem (P_36, R_4, minimal, formative) by (P_36, R_5, minimal, formative). Thus, the original system is terminating if (P_36, R_5, minimal, formative) is finite. We consider the dependency pair problem (P_36, R_5, minimal, formative). We will use the reduction pair processor [Kop12, Thm. 7.16]. It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(U51(tt, X)) >? mark#(U52(isNatList(X))) active#(isNat(s(X))) >? mark#(U21(isNat(X))) mark#(U21(X)) >? mark#(X) mark#(U42(X)) >? mark#(X) mark#(U51(X, Y)) >? active#(U51(mark(X), Y)) mark#(U52(X)) >? mark#(X) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) active(zeros) >= mark(cons(0, zeros)) active(U21(tt)) >= mark(tt) active(U41(tt, X)) >= mark(U42(isNatIList(X))) active(U42(tt)) >= mark(tt) active(U51(tt, X)) >= mark(U52(isNatList(X))) active(U52(tt)) >= mark(tt) active(U61(tt, X, Y)) >= mark(U62(isNat(Y), X)) active(U62(tt, X)) >= mark(s(length(X))) active(isNat(0)) >= mark(tt) active(isNat(s(X))) >= mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >= mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >= mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >= mark(U61(isNatList(Y), Y, X)) mark(zeros) >= active(zeros) mark(cons(X, Y)) >= active(cons(mark(X), Y)) mark(0) >= active(0) mark(U11(X)) >= active(U11(mark(X))) mark(tt) >= active(tt) mark(U21(X)) >= active(U21(mark(X))) mark(U31(X)) >= active(U31(mark(X))) mark(U41(X, Y)) >= active(U41(mark(X), Y)) mark(U42(X)) >= active(U42(mark(X))) mark(isNatIList(X)) >= active(isNatIList(X)) mark(U51(X, Y)) >= active(U51(mark(X), Y)) mark(U52(X)) >= active(U52(mark(X))) mark(isNatList(X)) >= active(isNatList(X)) mark(U61(X, Y, Z)) >= active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >= active(U62(mark(X), Y)) mark(isNat(X)) >= active(isNat(X)) mark(s(X)) >= active(s(mark(X))) mark(length(X)) >= active(length(mark(X))) mark(nil) >= active(nil) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U42(mark(X)) >= U42(X) U42(active(X)) >= U42(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) We orient these requirements with a polynomial interpretation in the natural numbers. We consider usable_rules with respect to the following argument filtering: active#(x_1) = active#() This leaves the following ordering requirements: active#(U51(tt, X)) >= mark#(U52(isNatList(X))) active#(isNat(s(X))) >= mark#(U21(isNat(X))) mark#(U21(X)) >= mark#(X) mark#(U42(X)) > mark#(X) mark#(U51(X, Y)) >= active#(U51(mark(X), Y)) mark#(U52(X)) >= mark#(X) mark#(isNat(X)) >= active#(isNat(X)) mark#(s(X)) >= mark#(X) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.0 U21 = \y0.2y0 U31 = \y0.0 U41 = \y0y1.0 U42 = \y0.1 + y0 U51 = \y0y1.0 U52 = \y0.y0 U61 = \y0y1y2.0 U62 = \y0y1.0 active = \y0.2y0 active# = \y0.0 cons = \y0y1.0 isNat = \y0.0 isNatIList = \y0.0 isNatList = \y0.0 length = \y0.0 mark = \y0.y0 mark# = \y0.2y0 nil = 0 s = \y0.y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active#(U51(tt, _x0))]] = 0 >= 0 = [[mark#(U52(isNatList(_x0)))]] [[active#(isNat(s(_x0)))]] = 0 >= 0 = [[mark#(U21(isNat(_x0)))]] [[mark#(U21(_x0))]] = 4x0 >= 2x0 = [[mark#(_x0)]] [[mark#(U42(_x0))]] = 2 + 2x0 > 2x0 = [[mark#(_x0)]] [[mark#(U51(_x0, _x1))]] = 0 >= 0 = [[active#(U51(mark(_x0), _x1))]] [[mark#(U52(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[mark#(isNat(_x0))]] = 0 >= 0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = 2x0 >= 2x0 = [[mark#(_x0)]] [[U21(mark(_x0))]] = 2x0 >= 2x0 = [[U21(_x0)]] [[U21(active(_x0))]] = 4x0 >= 2x0 = [[U21(_x0)]] [[isNat(mark(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 0 >= 0 = [[isNat(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_36, R_5, minimal, formative) by (P_37, R_5, minimal, formative), where P_37 consists of: active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) mark#(U21(X)) =#> mark#(X) mark#(U51(X, Y)) =#> active#(U51(mark(X), Y)) mark#(U52(X)) =#> mark#(X) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) Thus, the original system is terminating if (P_37, R_5, minimal, formative) is finite. We consider the dependency pair problem (P_37, R_5, minimal, formative). The formative rules of (P_37, R_5) are R_6 ::= active(zeros) => mark(cons(0, zeros)) active(U21(tt)) => mark(tt) active(U41(tt, X)) => mark(U42(isNatIList(X))) active(U42(tt)) => mark(tt) active(U51(tt, X)) => mark(U52(isNatList(X))) active(U52(tt)) => mark(tt) active(U61(tt, X, Y)) => mark(U62(isNat(Y), X)) active(U62(tt, X)) => mark(s(length(X))) active(isNat(0)) => mark(tt) active(isNat(s(X))) => mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) => mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) => mark(U51(isNat(X), Y)) active(length(cons(X, Y))) => mark(U61(isNatList(Y), Y, X)) mark(zeros) => active(zeros) mark(cons(X, Y)) => active(cons(mark(X), Y)) mark(0) => active(0) mark(U11(X)) => active(U11(mark(X))) mark(tt) => active(tt) mark(U21(X)) => active(U21(mark(X))) mark(U31(X)) => active(U31(mark(X))) mark(U41(X, Y)) => active(U41(mark(X), Y)) mark(U42(X)) => active(U42(mark(X))) mark(isNatIList(X)) => active(isNatIList(X)) mark(U51(X, Y)) => active(U51(mark(X), Y)) mark(U52(X)) => active(U52(mark(X))) mark(isNatList(X)) => active(isNatList(X)) mark(U61(X, Y, Z)) => active(U61(mark(X), Y, Z)) mark(U62(X, Y)) => active(U62(mark(X), Y)) mark(isNat(X)) => active(isNat(X)) mark(s(X)) => active(s(mark(X))) mark(length(X)) => active(length(mark(X))) mark(nil) => active(nil) U21(mark(X)) => U21(X) U21(active(X)) => U21(X) U51(mark(X), Y) => U51(X, Y) U51(X, mark(Y)) => U51(X, Y) U51(active(X), Y) => U51(X, Y) U51(X, active(Y)) => U51(X, Y) U52(mark(X)) => U52(X) U52(active(X)) => U52(X) isNat(mark(X)) => isNat(X) isNat(active(X)) => isNat(X) s(mark(X)) => s(X) s(active(X)) => s(X) By [Kop12, Thm. 7.17], we may replace the dependency pair problem (P_37, R_5, minimal, formative) by (P_37, R_6, minimal, formative). Thus, the original system is terminating if (P_37, R_6, minimal, formative) is finite. We consider the dependency pair problem (P_37, R_6, minimal, formative). We will use the reduction pair processor [Kop12, Thm. 7.16]. It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(U51(tt, X)) >? mark#(U52(isNatList(X))) active#(isNat(s(X))) >? mark#(U21(isNat(X))) mark#(U21(X)) >? mark#(X) mark#(U51(X, Y)) >? active#(U51(mark(X), Y)) mark#(U52(X)) >? mark#(X) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) active(zeros) >= mark(cons(0, zeros)) active(U21(tt)) >= mark(tt) active(U41(tt, X)) >= mark(U42(isNatIList(X))) active(U42(tt)) >= mark(tt) active(U51(tt, X)) >= mark(U52(isNatList(X))) active(U52(tt)) >= mark(tt) active(U61(tt, X, Y)) >= mark(U62(isNat(Y), X)) active(U62(tt, X)) >= mark(s(length(X))) active(isNat(0)) >= mark(tt) active(isNat(s(X))) >= mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) >= mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) >= mark(U51(isNat(X), Y)) active(length(cons(X, Y))) >= mark(U61(isNatList(Y), Y, X)) mark(zeros) >= active(zeros) mark(cons(X, Y)) >= active(cons(mark(X), Y)) mark(0) >= active(0) mark(U11(X)) >= active(U11(mark(X))) mark(tt) >= active(tt) mark(U21(X)) >= active(U21(mark(X))) mark(U31(X)) >= active(U31(mark(X))) mark(U41(X, Y)) >= active(U41(mark(X), Y)) mark(U42(X)) >= active(U42(mark(X))) mark(isNatIList(X)) >= active(isNatIList(X)) mark(U51(X, Y)) >= active(U51(mark(X), Y)) mark(U52(X)) >= active(U52(mark(X))) mark(isNatList(X)) >= active(isNatList(X)) mark(U61(X, Y, Z)) >= active(U61(mark(X), Y, Z)) mark(U62(X, Y)) >= active(U62(mark(X), Y)) mark(isNat(X)) >= active(isNat(X)) mark(s(X)) >= active(s(mark(X))) mark(length(X)) >= active(length(mark(X))) mark(nil) >= active(nil) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) U52(mark(X)) >= U52(X) U52(active(X)) >= U52(X) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) s(mark(X)) >= s(X) s(active(X)) >= s(X) We orient these requirements with a polynomial interpretation in the natural numbers. We consider usable_rules with respect to the following argument filtering: U51(x_1,x_2) = U51(x_2) This leaves the following ordering requirements: active#(U51(tt, X)) >= mark#(U52(isNatList(X))) active#(isNat(s(X))) >= mark#(U21(isNat(X))) mark#(U21(X)) >= mark#(X) mark#(U51(X, Y)) > active#(U51(mark(X), Y)) mark#(U52(X)) >= mark#(X) mark#(isNat(X)) >= active#(isNat(X)) mark#(s(X)) >= mark#(X) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) U51(mark(X), Y) >= U51(X, Y) U51(X, mark(Y)) >= U51(X, Y) U51(active(X), Y) >= U51(X, Y) U51(X, active(Y)) >= U51(X, Y) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) The following interpretation satisfies the requirements: 0 = 0 U11 = \y0.0 U21 = \y0.2y0 U31 = \y0.0 U41 = \y0y1.0 U42 = \y0.0 U51 = \y0y1.1 + 2y1 U52 = \y0.y0 U61 = \y0y1y2.0 U62 = \y0y1.0 active = \y0.2y0 active# = \y0.0 cons = \y0y1.0 isNat = \y0.0 isNatIList = \y0.0 isNatList = \y0.0 length = \y0.0 mark = \y0.y0 mark# = \y0.y0 nil = 0 s = \y0.2y0 tt = 0 zeros = 0 Using this interpretation, the requirements translate to: [[active#(U51(tt, _x0))]] = 0 >= 0 = [[mark#(U52(isNatList(_x0)))]] [[active#(isNat(s(_x0)))]] = 0 >= 0 = [[mark#(U21(isNat(_x0)))]] [[mark#(U21(_x0))]] = 2x0 >= x0 = [[mark#(_x0)]] [[mark#(U51(_x0, _x1))]] = 1 + 2x1 > 0 = [[active#(U51(mark(_x0), _x1))]] [[mark#(U52(_x0))]] = x0 >= x0 = [[mark#(_x0)]] [[mark#(isNat(_x0))]] = 0 >= 0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = 2x0 >= x0 = [[mark#(_x0)]] [[U21(mark(_x0))]] = 2x0 >= 2x0 = [[U21(_x0)]] [[U21(active(_x0))]] = 4x0 >= 2x0 = [[U21(_x0)]] [[U51(mark(_x0), _x1)]] = 1 + 2x1 >= 1 + 2x1 = [[U51(_x0, _x1)]] [[U51(_x0, mark(_x1))]] = 1 + 2x1 >= 1 + 2x1 = [[U51(_x0, _x1)]] [[U51(active(_x0), _x1)]] = 1 + 2x1 >= 1 + 2x1 = [[U51(_x0, _x1)]] [[U51(_x0, active(_x1))]] = 1 + 4x1 >= 1 + 2x1 = [[U51(_x0, _x1)]] [[isNat(mark(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 0 >= 0 = [[isNat(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_37, R_6, minimal, formative) by (P_38, R_6, minimal, formative), where P_38 consists of: active#(U51(tt, X)) =#> mark#(U52(isNatList(X))) active#(isNat(s(X))) =#> mark#(U21(isNat(X))) mark#(U21(X)) =#> mark#(X) mark#(U52(X)) =#> mark#(X) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) Thus, the original system is terminating if (P_38, R_6, minimal, formative) is finite. We consider the dependency pair problem (P_38, R_6, minimal, formative). We place the elements of P in a dependency graph approximation G (see e.g. [Kop12, Thm. 7.27, 7.29], as follows: * 0 : 3 * 1 : 2 * 2 : 2, 3, 4, 5 * 3 : 2, 3, 4, 5 * 4 : 1 * 5 : 2, 3, 4, 5 This graph has the following strongly connected components: P_39: active#(isNat(s(X))) =#> mark#(U21(isNat(X))) mark#(U21(X)) =#> mark#(X) mark#(U52(X)) =#> mark#(X) mark#(isNat(X)) =#> active#(isNat(X)) mark#(s(X)) =#> mark#(X) By [Kop12, Thm. 7.31], we may replace any dependency pair problem (P_38, R_6, m, f) by (P_39, R_6, m, f). Thus, the original system is terminating if (P_39, R_6, minimal, formative) is finite. We consider the dependency pair problem (P_39, R_6, minimal, formative). The formative rules of (P_39, R_6) are R_7 ::= active(zeros) => mark(cons(0, zeros)) active(U21(tt)) => mark(tt) active(U41(tt, X)) => mark(U42(isNatIList(X))) active(U42(tt)) => mark(tt) active(U51(tt, X)) => mark(U52(isNatList(X))) active(U52(tt)) => mark(tt) active(U61(tt, X, Y)) => mark(U62(isNat(Y), X)) active(U62(tt, X)) => mark(s(length(X))) active(isNat(0)) => mark(tt) active(isNat(s(X))) => mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) => mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) => mark(U51(isNat(X), Y)) active(length(cons(X, Y))) => mark(U61(isNatList(Y), Y, X)) mark(zeros) => active(zeros) mark(cons(X, Y)) => active(cons(mark(X), Y)) mark(0) => active(0) mark(U11(X)) => active(U11(mark(X))) mark(tt) => active(tt) mark(U21(X)) => active(U21(mark(X))) mark(U31(X)) => active(U31(mark(X))) mark(U41(X, Y)) => active(U41(mark(X), Y)) mark(U42(X)) => active(U42(mark(X))) mark(isNatIList(X)) => active(isNatIList(X)) mark(U51(X, Y)) => active(U51(mark(X), Y)) mark(U52(X)) => active(U52(mark(X))) mark(isNatList(X)) => active(isNatList(X)) mark(U61(X, Y, Z)) => active(U61(mark(X), Y, Z)) mark(U62(X, Y)) => active(U62(mark(X), Y)) mark(isNat(X)) => active(isNat(X)) mark(s(X)) => active(s(mark(X))) mark(length(X)) => active(length(mark(X))) mark(nil) => active(nil) U21(mark(X)) => U21(X) U21(active(X)) => U21(X) U52(mark(X)) => U52(X) U52(active(X)) => U52(X) isNat(mark(X)) => isNat(X) isNat(active(X)) => isNat(X) s(mark(X)) => s(X) s(active(X)) => s(X) By [Kop12, Thm. 7.17], we may replace the dependency pair problem (P_39, R_6, minimal, formative) by (P_39, R_7, minimal, formative). Thus, the original system is terminating if (P_39, R_7, minimal, formative) is finite. We consider the dependency pair problem (P_39, R_7, minimal, formative). We will use the reduction pair processor with usable rules [Kop12, Thm. 7.44]. The usable rules of (P_39, R_7) are: U21(mark(X)) => U21(X) U21(active(X)) => U21(X) isNat(mark(X)) => isNat(X) isNat(active(X)) => isNat(X) It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(isNat(s(X))) >? mark#(U21(isNat(X))) mark#(U21(X)) >? mark#(X) mark#(U52(X)) >? mark#(X) mark#(isNat(X)) >? active#(isNat(X)) mark#(s(X)) >? mark#(X) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: U21 = \y0.y0 U52 = \y0.3 + y0 active = \y0.y0 active# = \y0.0 isNat = \y0.0 mark = \y0.2y0 mark# = \y0.y0 s = \y0.3 + 2y0 Using this interpretation, the requirements translate to: [[active#(isNat(s(_x0)))]] = 0 >= 0 = [[mark#(U21(isNat(_x0)))]] [[mark#(U21(_x0))]] = x0 >= x0 = [[mark#(_x0)]] [[mark#(U52(_x0))]] = 3 + x0 > x0 = [[mark#(_x0)]] [[mark#(isNat(_x0))]] = 0 >= 0 = [[active#(isNat(_x0))]] [[mark#(s(_x0))]] = 3 + 2x0 > x0 = [[mark#(_x0)]] [[U21(mark(_x0))]] = 2x0 >= x0 = [[U21(_x0)]] [[U21(active(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[isNat(mark(_x0))]] = 0 >= 0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 0 >= 0 = [[isNat(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_39, R_7, minimal, formative) by (P_40, R_7, minimal, formative), where P_40 consists of: active#(isNat(s(X))) =#> mark#(U21(isNat(X))) mark#(U21(X)) =#> mark#(X) mark#(isNat(X)) =#> active#(isNat(X)) Thus, the original system is terminating if (P_40, R_7, minimal, formative) is finite. We consider the dependency pair problem (P_40, R_7, minimal, formative). The formative rules of (P_40, R_7) are R_8 ::= active(zeros) => mark(cons(0, zeros)) active(U21(tt)) => mark(tt) active(U41(tt, X)) => mark(U42(isNatIList(X))) active(U42(tt)) => mark(tt) active(U51(tt, X)) => mark(U52(isNatList(X))) active(U52(tt)) => mark(tt) active(U61(tt, X, Y)) => mark(U62(isNat(Y), X)) active(U62(tt, X)) => mark(s(length(X))) active(isNat(0)) => mark(tt) active(isNat(s(X))) => mark(U21(isNat(X))) active(isNatIList(cons(X, Y))) => mark(U41(isNat(X), Y)) active(isNatList(cons(X, Y))) => mark(U51(isNat(X), Y)) active(length(cons(X, Y))) => mark(U61(isNatList(Y), Y, X)) mark(zeros) => active(zeros) mark(cons(X, Y)) => active(cons(mark(X), Y)) mark(0) => active(0) mark(U11(X)) => active(U11(mark(X))) mark(tt) => active(tt) mark(U21(X)) => active(U21(mark(X))) mark(U31(X)) => active(U31(mark(X))) mark(U41(X, Y)) => active(U41(mark(X), Y)) mark(U42(X)) => active(U42(mark(X))) mark(isNatIList(X)) => active(isNatIList(X)) mark(U51(X, Y)) => active(U51(mark(X), Y)) mark(U52(X)) => active(U52(mark(X))) mark(isNatList(X)) => active(isNatList(X)) mark(U61(X, Y, Z)) => active(U61(mark(X), Y, Z)) mark(U62(X, Y)) => active(U62(mark(X), Y)) mark(isNat(X)) => active(isNat(X)) mark(s(X)) => active(s(mark(X))) mark(length(X)) => active(length(mark(X))) mark(nil) => active(nil) U21(mark(X)) => U21(X) U21(active(X)) => U21(X) isNat(mark(X)) => isNat(X) isNat(active(X)) => isNat(X) s(mark(X)) => s(X) s(active(X)) => s(X) By [Kop12, Thm. 7.17], we may replace the dependency pair problem (P_40, R_7, minimal, formative) by (P_40, R_8, minimal, formative). Thus, the original system is terminating if (P_40, R_8, minimal, formative) is finite. We consider the dependency pair problem (P_40, R_8, minimal, formative). We will use the reduction pair processor with usable rules [Kop12, Thm. 7.44]. The usable rules of (P_40, R_8) are: U21(mark(X)) => U21(X) U21(active(X)) => U21(X) isNat(mark(X)) => isNat(X) isNat(active(X)) => isNat(X) It suffices to find a standard reduction pair [Kop12, Def. 6.69]. Thus, we must orient: active#(isNat(s(X))) >? mark#(U21(isNat(X))) mark#(U21(X)) >? mark#(X) mark#(isNat(X)) >? active#(isNat(X)) U21(mark(X)) >= U21(X) U21(active(X)) >= U21(X) isNat(mark(X)) >= isNat(X) isNat(active(X)) >= isNat(X) We orient these requirements with a polynomial interpretation in the natural numbers. The following interpretation satisfies the requirements: U21 = \y0.y0 active = \y0.y0 active# = \y0.y0 isNat = \y0.2y0 mark = \y0.2y0 mark# = \y0.1 + y0 s = \y0.3 + y0 Using this interpretation, the requirements translate to: [[active#(isNat(s(_x0)))]] = 6 + 2x0 > 1 + 2x0 = [[mark#(U21(isNat(_x0)))]] [[mark#(U21(_x0))]] = 1 + x0 >= 1 + x0 = [[mark#(_x0)]] [[mark#(isNat(_x0))]] = 1 + 2x0 > 2x0 = [[active#(isNat(_x0))]] [[U21(mark(_x0))]] = 2x0 >= x0 = [[U21(_x0)]] [[U21(active(_x0))]] = x0 >= x0 = [[U21(_x0)]] [[isNat(mark(_x0))]] = 4x0 >= 2x0 = [[isNat(_x0)]] [[isNat(active(_x0))]] = 2x0 >= 2x0 = [[isNat(_x0)]] By the observations in [Kop12, Sec. 6.6], this reduction pair suffices; we may thus replace the dependency pair problem (P_40, R_8, minimal, formative) by (P_41, R_8, minimal, formative), where P_41 consists of: mark#(U21(X)) =#> mark#(X) Thus, the original system is terminating if (P_41, R_8, minimal, formative) is finite. We consider the dependency pair problem (P_41, R_8, minimal, formative). We apply the subterm criterion with the following projection function: nu(mark#) = 1 Thus, we can orient the dependency pairs as follows: nu(mark#(U21(X))) = U21(X) |> X = nu(mark#(X)) By [Kop12, Thm. 7.35], we may replace a dependency pair problem (P_41, R_8, minimal, f) by ({}, R_8, minimal, f). By the empty set processor [Kop12, Thm. 7.15] this problem may be immediately removed. As all dependency pair problems were succesfully simplified with sound (and complete) processors until nothing remained, we conclude termination. +++ Citations +++ [Kop12] C. Kop. Higher Order Termination. PhD Thesis, 2012. [KusIsoSakBla09] K. Kusakari, Y. Isogai, M. Sakai, and F. Blanqui. Static Dependency Pair Method Based On Strong Computability for Higher-Order Rewrite Systems. In volume 92(10) of IEICE Transactions on Information and Systems. 2007--2015, 2009.