Termination w.r.t. Q of the given QTRS could be proven:

(0) Obligation:

Q restricted rewrite system:
The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, V1)) → mark(U12(isNatList(V1)))
active(U12(tt)) → mark(tt)
active(U21(tt, V1)) → mark(U22(isNat(V1)))
active(U22(tt)) → mark(tt)
active(U31(tt, V)) → mark(U32(isNatList(V)))
active(U32(tt)) → mark(tt)
active(U41(tt, V1, V2)) → mark(U42(isNat(V1), V2))
active(U42(tt, V2)) → mark(U43(isNatIList(V2)))
active(U43(tt)) → mark(tt)
active(U51(tt, V1, V2)) → mark(U52(isNat(V1), V2))
active(U52(tt, V2)) → mark(U53(isNatList(V2)))
active(U53(tt)) → mark(tt)
active(U61(tt, L)) → mark(s(length(L)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(U11(isNatIListKind(V1), V1))
active(isNat(s(V1))) → mark(U21(isNatKind(V1), V1))
active(isNatIList(V)) → mark(U31(isNatIListKind(V), V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2))
active(isNatIListKind(nil)) → mark(tt)
active(isNatIListKind(zeros)) → mark(tt)
active(isNatIListKind(cons(V1, V2))) → mark(and(isNatKind(V1), isNatIListKind(V2)))
active(isNatKind(0)) → mark(tt)
active(isNatKind(length(V1))) → mark(isNatIListKind(V1))
active(isNatKind(s(V1))) → mark(isNatKind(V1))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L))
active(cons(X1, X2)) → cons(active(X1), X2)
active(U11(X1, X2)) → U11(active(X1), X2)
active(U12(X)) → U12(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U22(X)) → U22(active(X))
active(U31(X1, X2)) → U31(active(X1), X2)
active(U32(X)) → U32(active(X))
active(U41(X1, X2, X3)) → U41(active(X1), X2, X3)
active(U42(X1, X2)) → U42(active(X1), X2)
active(U43(X)) → U43(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(U52(X1, X2)) → U52(active(X1), X2)
active(U53(X)) → U53(active(X))
active(U61(X1, X2)) → U61(active(X1), X2)
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(and(X1, X2)) → and(active(X1), X2)
cons(mark(X1), X2) → mark(cons(X1, X2))
U11(mark(X1), X2) → mark(U11(X1, X2))
U12(mark(X)) → mark(U12(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U22(mark(X)) → mark(U22(X))
U31(mark(X1), X2) → mark(U31(X1, X2))
U32(mark(X)) → mark(U32(X))
U41(mark(X1), X2, X3) → mark(U41(X1, X2, X3))
U42(mark(X1), X2) → mark(U42(X1, X2))
U43(mark(X)) → mark(U43(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
U52(mark(X1), X2) → mark(U52(X1, X2))
U53(mark(X)) → mark(U53(X))
U61(mark(X1), X2) → mark(U61(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
and(mark(X1), X2) → mark(and(X1, X2))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(U11(X1, X2)) → U11(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U22(X)) → U22(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U32(X)) → U32(proper(X))
proper(U41(X1, X2, X3)) → U41(proper(X1), proper(X2), proper(X3))
proper(U42(X1, X2)) → U42(proper(X1), proper(X2))
proper(U43(X)) → U43(proper(X))
proper(isNatIList(X)) → isNatIList(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(U52(X1, X2)) → U52(proper(X1), proper(X2))
proper(U53(X)) → U53(proper(X))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatIListKind(X)) → isNatIListKind(proper(X))
proper(isNatKind(X)) → isNatKind(proper(X))
proper(nil) → ok(nil)
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
U11(ok(X1), ok(X2)) → ok(U11(X1, X2))
U12(ok(X)) → ok(U12(X))
isNatList(ok(X)) → ok(isNatList(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U22(ok(X)) → ok(U22(X))
isNat(ok(X)) → ok(isNat(X))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U32(ok(X)) → ok(U32(X))
U41(ok(X1), ok(X2), ok(X3)) → ok(U41(X1, X2, X3))
U42(ok(X1), ok(X2)) → ok(U42(X1, X2))
U43(ok(X)) → ok(U43(X))
isNatIList(ok(X)) → ok(isNatIList(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
U52(ok(X1), ok(X2)) → ok(U52(X1, X2))
U53(ok(X)) → ok(U53(X))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIListKind(ok(X)) → ok(isNatIListKind(X))
isNatKind(ok(X)) → ok(isNatKind(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.

(1) QTRSToCSRProof (EQUIVALENT transformation)

The following Q TRS is given: Q restricted rewrite system:
The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, V1)) → mark(U12(isNatList(V1)))
active(U12(tt)) → mark(tt)
active(U21(tt, V1)) → mark(U22(isNat(V1)))
active(U22(tt)) → mark(tt)
active(U31(tt, V)) → mark(U32(isNatList(V)))
active(U32(tt)) → mark(tt)
active(U41(tt, V1, V2)) → mark(U42(isNat(V1), V2))
active(U42(tt, V2)) → mark(U43(isNatIList(V2)))
active(U43(tt)) → mark(tt)
active(U51(tt, V1, V2)) → mark(U52(isNat(V1), V2))
active(U52(tt, V2)) → mark(U53(isNatList(V2)))
active(U53(tt)) → mark(tt)
active(U61(tt, L)) → mark(s(length(L)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(U11(isNatIListKind(V1), V1))
active(isNat(s(V1))) → mark(U21(isNatKind(V1), V1))
active(isNatIList(V)) → mark(U31(isNatIListKind(V), V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2))
active(isNatIListKind(nil)) → mark(tt)
active(isNatIListKind(zeros)) → mark(tt)
active(isNatIListKind(cons(V1, V2))) → mark(and(isNatKind(V1), isNatIListKind(V2)))
active(isNatKind(0)) → mark(tt)
active(isNatKind(length(V1))) → mark(isNatIListKind(V1))
active(isNatKind(s(V1))) → mark(isNatKind(V1))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L))
active(cons(X1, X2)) → cons(active(X1), X2)
active(U11(X1, X2)) → U11(active(X1), X2)
active(U12(X)) → U12(active(X))
active(U21(X1, X2)) → U21(active(X1), X2)
active(U22(X)) → U22(active(X))
active(U31(X1, X2)) → U31(active(X1), X2)
active(U32(X)) → U32(active(X))
active(U41(X1, X2, X3)) → U41(active(X1), X2, X3)
active(U42(X1, X2)) → U42(active(X1), X2)
active(U43(X)) → U43(active(X))
active(U51(X1, X2, X3)) → U51(active(X1), X2, X3)
active(U52(X1, X2)) → U52(active(X1), X2)
active(U53(X)) → U53(active(X))
active(U61(X1, X2)) → U61(active(X1), X2)
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(and(X1, X2)) → and(active(X1), X2)
cons(mark(X1), X2) → mark(cons(X1, X2))
U11(mark(X1), X2) → mark(U11(X1, X2))
U12(mark(X)) → mark(U12(X))
U21(mark(X1), X2) → mark(U21(X1, X2))
U22(mark(X)) → mark(U22(X))
U31(mark(X1), X2) → mark(U31(X1, X2))
U32(mark(X)) → mark(U32(X))
U41(mark(X1), X2, X3) → mark(U41(X1, X2, X3))
U42(mark(X1), X2) → mark(U42(X1, X2))
U43(mark(X)) → mark(U43(X))
U51(mark(X1), X2, X3) → mark(U51(X1, X2, X3))
U52(mark(X1), X2) → mark(U52(X1, X2))
U53(mark(X)) → mark(U53(X))
U61(mark(X1), X2) → mark(U61(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
and(mark(X1), X2) → mark(and(X1, X2))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(0) → ok(0)
proper(U11(X1, X2)) → U11(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(U12(X)) → U12(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(U21(X1, X2)) → U21(proper(X1), proper(X2))
proper(U22(X)) → U22(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(U31(X1, X2)) → U31(proper(X1), proper(X2))
proper(U32(X)) → U32(proper(X))
proper(U41(X1, X2, X3)) → U41(proper(X1), proper(X2), proper(X3))
proper(U42(X1, X2)) → U42(proper(X1), proper(X2))
proper(U43(X)) → U43(proper(X))
proper(isNatIList(X)) → isNatIList(proper(X))
proper(U51(X1, X2, X3)) → U51(proper(X1), proper(X2), proper(X3))
proper(U52(X1, X2)) → U52(proper(X1), proper(X2))
proper(U53(X)) → U53(proper(X))
proper(U61(X1, X2)) → U61(proper(X1), proper(X2))
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(isNatIListKind(X)) → isNatIListKind(proper(X))
proper(isNatKind(X)) → isNatKind(proper(X))
proper(nil) → ok(nil)
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
U11(ok(X1), ok(X2)) → ok(U11(X1, X2))
U12(ok(X)) → ok(U12(X))
isNatList(ok(X)) → ok(isNatList(X))
U21(ok(X1), ok(X2)) → ok(U21(X1, X2))
U22(ok(X)) → ok(U22(X))
isNat(ok(X)) → ok(isNat(X))
U31(ok(X1), ok(X2)) → ok(U31(X1, X2))
U32(ok(X)) → ok(U32(X))
U41(ok(X1), ok(X2), ok(X3)) → ok(U41(X1, X2, X3))
U42(ok(X1), ok(X2)) → ok(U42(X1, X2))
U43(ok(X)) → ok(U43(X))
isNatIList(ok(X)) → ok(isNatIList(X))
U51(ok(X1), ok(X2), ok(X3)) → ok(U51(X1, X2, X3))
U52(ok(X1), ok(X2)) → ok(U52(X1, X2))
U53(ok(X)) → ok(U53(X))
U61(ok(X1), ok(X2)) → ok(U61(X1, X2))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIListKind(ok(X)) → ok(isNatIListKind(X))
isNatKind(ok(X)) → ok(isNatKind(X))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.
Special symbols used for the transformation (see [GM04]):
top: top, active: active, mark: mark, ok: ok, proper: proper
The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U12: {1}
isNatList: empty set
U21: {1}
U22: {1}
isNat: empty set
U31: {1}
U32: {1}
U41: {1}
U42: {1}
U43: {1}
isNatIList: empty set
U51: {1}
U52: {1}
U53: {1}
U61: {1}
s: {1}
length: {1}
and: {1}
isNatIListKind: empty set
isNatKind: empty set
nil: empty set
The QTRS contained all rules created by the complete Giesl-Middeldorp transformation. Therefore, the inverse transformation is complete (and sound).

(2) Obligation:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

zeros → cons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(nil) → 0
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U12: {1}
isNatList: empty set
U21: {1}
U22: {1}
isNat: empty set
U31: {1}
U32: {1}
U41: {1}
U42: {1}
U43: {1}
isNatIList: empty set
U51: {1}
U52: {1}
U53: {1}
U61: {1}
s: {1}
length: {1}
and: {1}
isNatIListKind: empty set
isNatKind: empty set
nil: empty set

(3) PoloCSRProof (EQUIVALENT transformation)

The following rules can be removed because they are oriented strictly by a µ-monotonic polynomial ordering:

length(nil) → 0

Used ordering:
Polynomial interpretation [POLO]:

POL(0) = 0   
POL(U11(x₁, x₂)) = x₁   
POL(U12(x₁)) = 2·x₁   
POL(U21(x₁, x₂)) = 2·x₁   
POL(U22(x₁)) = 2·x₁   
POL(U31(x₁, x₂)) = x₁   
POL(U32(x₁)) = 2·x₁   
POL(U41(x₁, x₂, x₃)) = x₁   
POL(U42(x₁, x₂)) = 2·x₁   
POL(U43(x₁)) = x₁   
POL(U51(x₁, x₂, x₃)) = x₁   
POL(U52(x₁, x₂)) = 2·x₁   
POL(U53(x₁)) = 2·x₁   
POL(U61(x₁, x₂)) = x₁ + x₂   
POL(and(x₁, x₂)) = 2·x₁ + x₂   
POL(cons(x₁, x₂)) = 2·x₁ + x₂   
POL(isNat(x₁)) = 0   
POL(isNatIList(x₁)) = 0   
POL(isNatIListKind(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatList(x₁)) = 0   
POL(length(x₁)) = x₁   
POL(nil) = 1   
POL(s(x₁)) = x₁   
POL(tt) = 0   
POL(zeros) = 0   

(4) Obligation:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

zeros → cons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U31(tt, V) → U32(isNatList(V))
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U12: {1}
isNatList: empty set
U21: {1}
U22: {1}
isNat: empty set
U31: {1}
U32: {1}
U41: {1}
U42: {1}
U43: {1}
isNatIList: empty set
U51: {1}
U52: {1}
U53: {1}
U61: {1}
s: {1}
length: {1}
and: {1}
isNatIListKind: empty set
isNatKind: empty set
nil: empty set

(5) PoloCSRProof (EQUIVALENT transformation)

The following rules can be removed because they are oriented strictly by a µ-monotonic polynomial ordering:

U31(tt, V) → U32(isNatList(V))
isNatIList(zeros) → tt

Used ordering:
Polynomial interpretation [POLO]:

POL(0) = 0   
POL(U11(x₁, x₂)) = 2·x₁   
POL(U12(x₁)) = x₁   
POL(U21(x₁, x₂)) = x₁   
POL(U22(x₁)) = 2·x₁   
POL(U31(x₁, x₂)) = 1 + x₁   
POL(U32(x₁)) = x₁   
POL(U41(x₁, x₂, x₃)) = 1 + x₁   
POL(U42(x₁, x₂)) = 1 + 2·x₁   
POL(U43(x₁)) = x₁   
POL(U51(x₁, x₂, x₃)) = x₁   
POL(U52(x₁, x₂)) = x₁   
POL(U53(x₁)) = 2·x₁   
POL(U61(x₁, x₂)) = x₁ + 2·x₂   
POL(and(x₁, x₂)) = 2·x₁ + 2·x₂   
POL(cons(x₁, x₂)) = 2·x₁ + 2·x₂   
POL(isNat(x₁)) = 0   
POL(isNatIList(x₁)) = 1   
POL(isNatIListKind(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatList(x₁)) = 0   
POL(length(x₁)) = x₁   
POL(nil) = 1   
POL(s(x₁)) = 2·x₁   
POL(tt) = 0   
POL(zeros) = 0   

(6) Obligation:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

zeros → cons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U32(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U12: {1}
isNatList: empty set
U21: {1}
U22: {1}
isNat: empty set
U31: {1}
U32: {1}
U41: {1}
U42: {1}
U43: {1}
isNatIList: empty set
U51: {1}
U52: {1}
U53: {1}
U61: {1}
s: {1}
length: {1}
and: {1}
isNatIListKind: empty set
isNatKind: empty set
nil: empty set

(7) PoloCSRProof (EQUIVALENT transformation)

The following rules can be removed because they are oriented strictly by a µ-monotonic polynomial ordering:

U32(tt) → tt

Used ordering:
Polynomial interpretation [POLO]:

POL(0) = 0   
POL(U11(x₁, x₂)) = 2·x₁   
POL(U12(x₁)) = x₁   
POL(U21(x₁, x₂)) = 2·x₁   
POL(U22(x₁)) = 2·x₁   
POL(U31(x₁, x₂)) = 2·x₁   
POL(U32(x₁)) = 1 + 2·x₁   
POL(U41(x₁, x₂, x₃)) = 2·x₁   
POL(U42(x₁, x₂)) = x₁   
POL(U43(x₁)) = 2·x₁   
POL(U51(x₁, x₂, x₃)) = x₁   
POL(U52(x₁, x₂)) = x₁   
POL(U53(x₁)) = 2·x₁   
POL(U61(x₁, x₂)) = 2 + 2·x₁ + x₂   
POL(and(x₁, x₂)) = 2·x₁ + 2·x₂   
POL(cons(x₁, x₂)) = x₁ + x₂   
POL(isNat(x₁)) = 0   
POL(isNatIList(x₁)) = 0   
POL(isNatIListKind(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatList(x₁)) = 0   
POL(length(x₁)) = 2 + x₁   
POL(nil) = 2   
POL(s(x₁)) = x₁   
POL(tt) = 0   
POL(zeros) = 0   

(8) Obligation:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

zeros → cons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(V) → U31(isNatIListKind(V), V)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U12: {1}
isNatList: empty set
U21: {1}
U22: {1}
isNat: empty set
U31: {1}
U41: {1}
U42: {1}
U43: {1}
isNatIList: empty set
U51: {1}
U52: {1}
U53: {1}
U61: {1}
s: {1}
length: {1}
and: {1}
isNatIListKind: empty set
isNatKind: empty set
nil: empty set

(9) PoloCSRProof (EQUIVALENT transformation)

The following rules can be removed because they are oriented strictly by a µ-monotonic polynomial ordering:

isNatIList(V) → U31(isNatIListKind(V), V)

Used ordering:
Polynomial interpretation [POLO]:

POL(0) = 0   
POL(U11(x₁, x₂)) = 2·x₁   
POL(U12(x₁)) = 2·x₁   
POL(U21(x₁, x₂)) = 2·x₁   
POL(U22(x₁)) = 2·x₁   
POL(U31(x₁, x₂)) = 1 + x₁   
POL(U41(x₁, x₂, x₃)) = 2 + 2·x₁   
POL(U42(x₁, x₂)) = 2 + 2·x₁   
POL(U43(x₁)) = x₁   
POL(U51(x₁, x₂, x₃)) = x₁   
POL(U52(x₁, x₂)) = x₁   
POL(U53(x₁)) = 2·x₁   
POL(U61(x₁, x₂)) = 2·x₁ + x₂   
POL(and(x₁, x₂)) = 2·x₁ + 2·x₂   
POL(cons(x₁, x₂)) = 2·x₁ + x₂   
POL(isNat(x₁)) = 0   
POL(isNatIList(x₁)) = 2   
POL(isNatIListKind(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatList(x₁)) = 0   
POL(length(x₁)) = x₁   
POL(nil) = 1   
POL(s(x₁)) = x₁   
POL(tt) = 0   
POL(zeros) = 0   

(10) Obligation:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

zeros → cons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(nil) → tt
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U12: {1}
isNatList: empty set
U21: {1}
U22: {1}
isNat: empty set
U41: {1}
U42: {1}
U43: {1}
isNatIList: empty set
U51: {1}
U52: {1}
U53: {1}
U61: {1}
s: {1}
length: {1}
and: {1}
isNatIListKind: empty set
isNatKind: empty set
nil: empty set

(11) PoloCSRProof (EQUIVALENT transformation)

The following rules can be removed because they are oriented strictly by a µ-monotonic polynomial ordering:

isNatList(nil) → tt

Used ordering:
Polynomial interpretation [POLO]:

POL(0) = 0   
POL(U11(x₁, x₂)) = 2·x₁ + x₂   
POL(U12(x₁)) = x₁   
POL(U21(x₁, x₂)) = 2·x₁ + x₂   
POL(U22(x₁)) = x₁   
POL(U41(x₁, x₂, x₃)) = 2·x₁ + 2·x₂ + 2·x₃   
POL(U42(x₁, x₂)) = 2·x₁ + 2·x₂   
POL(U43(x₁)) = x₁   
POL(U51(x₁, x₂, x₃)) = x₁ + x₂ + 2·x₃   
POL(U52(x₁, x₂)) = x₁ + x₂   
POL(U53(x₁)) = x₁   
POL(U61(x₁, x₂)) = x₁ + 2·x₂   
POL(and(x₁, x₂)) = x₁ + 2·x₂   
POL(cons(x₁, x₂)) = 2·x₁ + 2·x₂   
POL(isNat(x₁)) = x₁   
POL(isNatIList(x₁)) = 2·x₁   
POL(isNatIListKind(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatList(x₁)) = x₁   
POL(length(x₁)) = 2·x₁   
POL(nil) = 2   
POL(s(x₁)) = x₁   
POL(tt) = 0   
POL(zeros) = 0   

(12) Obligation:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

zeros → cons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → U11(isNatIListKind(V1), V1)
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U12: {1}
isNatList: empty set
U21: {1}
U22: {1}
isNat: empty set
U41: {1}
U42: {1}
U43: {1}
isNatIList: empty set
U51: {1}
U52: {1}
U53: {1}
U61: {1}
s: {1}
length: {1}
and: {1}
isNatIListKind: empty set
isNatKind: empty set
nil: empty set

(13) PoloCSRProof (EQUIVALENT transformation)

The following rules can be removed because they are oriented strictly by a µ-monotonic polynomial ordering:

isNat(length(V1)) → U11(isNatIListKind(V1), V1)

Used ordering:
Polynomial interpretation [POLO]:

POL(0) = 0   
POL(U11(x₁, x₂)) = x₁ + x₂   
POL(U12(x₁)) = x₁   
POL(U21(x₁, x₂)) = x₁ + x₂   
POL(U22(x₁)) = x₁   
POL(U41(x₁, x₂, x₃)) = 2·x₁ + x₂ + 2·x₃   
POL(U42(x₁, x₂)) = x₁ + 2·x₂   
POL(U43(x₁)) = 2·x₁   
POL(U51(x₁, x₂, x₃)) = x₁ + x₂ + 2·x₃   
POL(U52(x₁, x₂)) = x₁ + 2·x₂   
POL(U53(x₁)) = x₁   
POL(U61(x₁, x₂)) = 1 + 2·x₁ + 2·x₂   
POL(and(x₁, x₂)) = x₁ + 2·x₂   
POL(cons(x₁, x₂)) = 2·x₁ + 2·x₂   
POL(isNat(x₁)) = x₁   
POL(isNatIList(x₁)) = x₁   
POL(isNatIListKind(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatList(x₁)) = x₁   
POL(length(x₁)) = 1 + 2·x₁   
POL(nil) = 2   
POL(s(x₁)) = x₁   
POL(tt) = 0   
POL(zeros) = 0   

(14) Obligation:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

zeros → cons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U12(tt) → tt
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U12: {1}
isNatList: empty set
U21: {1}
U22: {1}
isNat: empty set
U41: {1}
U42: {1}
U43: {1}
isNatIList: empty set
U51: {1}
U52: {1}
U53: {1}
U61: {1}
s: {1}
length: {1}
and: {1}
isNatIListKind: empty set
isNatKind: empty set
nil: empty set

(15) PoloCSRProof (EQUIVALENT transformation)

The following rules can be removed because they are oriented strictly by a µ-monotonic polynomial ordering:

U12(tt) → tt

Used ordering:
Polynomial interpretation [POLO]:

POL(0) = 0   
POL(U11(x₁, x₂)) = 2 + 2·x₁ + 2·x₂   
POL(U12(x₁)) = 2 + 2·x₁   
POL(U21(x₁, x₂)) = x₁   
POL(U22(x₁)) = 2·x₁   
POL(U41(x₁, x₂, x₃)) = x₁   
POL(U42(x₁, x₂)) = 2·x₁   
POL(U43(x₁)) = x₁   
POL(U51(x₁, x₂, x₃)) = 2·x₁   
POL(U52(x₁, x₂)) = 2·x₁   
POL(U53(x₁)) = x₁   
POL(U61(x₁, x₂)) = 1 + 2·x₁ + 2·x₂   
POL(and(x₁, x₂)) = 2·x₁ + 2·x₂   
POL(cons(x₁, x₂)) = 2·x₁ + 2·x₂   
POL(isNat(x₁)) = 0   
POL(isNatIList(x₁)) = 0   
POL(isNatIListKind(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatList(x₁)) = 0   
POL(length(x₁)) = 1 + x₁   
POL(nil) = 1   
POL(s(x₁)) = x₁   
POL(tt) = 0   
POL(zeros) = 0   

(16) Obligation:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

zeros → cons(0, zeros)
U11(tt, V1) → U12(isNatList(V1))
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
U12: {1}
isNatList: empty set
U21: {1}
U22: {1}
isNat: empty set
U41: {1}
U42: {1}
U43: {1}
isNatIList: empty set
U51: {1}
U52: {1}
U53: {1}
U61: {1}
s: {1}
length: {1}
and: {1}
isNatIListKind: empty set
isNatKind: empty set
nil: empty set

(17) PoloCSRProof (EQUIVALENT transformation)

The following rules can be removed because they are oriented strictly by a µ-monotonic polynomial ordering:

U11(tt, V1) → U12(isNatList(V1))

Used ordering:
Polynomial interpretation [POLO]:

POL(0) = 0   
POL(U11(x₁, x₂)) = 2 + x₁ + 2·x₂   
POL(U12(x₁)) = 1 + x₁   
POL(U21(x₁, x₂)) = 2·x₁   
POL(U22(x₁)) = x₁   
POL(U41(x₁, x₂, x₃)) = 2·x₁   
POL(U42(x₁, x₂)) = x₁   
POL(U43(x₁)) = 2·x₁   
POL(U51(x₁, x₂, x₃)) = x₁   
POL(U52(x₁, x₂)) = x₁   
POL(U53(x₁)) = 2·x₁   
POL(U61(x₁, x₂)) = x₁ + x₂   
POL(and(x₁, x₂)) = 2·x₁ + 2·x₂   
POL(cons(x₁, x₂)) = 2·x₁ + 2·x₂   
POL(isNat(x₁)) = 0   
POL(isNatIList(x₁)) = 0   
POL(isNatIListKind(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatList(x₁)) = 0   
POL(length(x₁)) = x₁   
POL(nil) = 2   
POL(s(x₁)) = x₁   
POL(tt) = 0   
POL(zeros) = 0   

(18) Obligation:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
tt: empty set
isNatList: empty set
U21: {1}
U22: {1}
isNat: empty set
U41: {1}
U42: {1}
U43: {1}
isNatIList: empty set
U51: {1}
U52: {1}
U53: {1}
U61: {1}
s: {1}
length: {1}
and: {1}
isNatIListKind: empty set
isNatKind: empty set
nil: empty set

(19) CSDependencyPairsProof (EQUIVALENT transformation)

Using Improved CS-DPs [LPAR08] we result in the following initial Q-CSDP problem.

(20) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length, U22', U43', U53', LENGTH} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, U21', U42', U41', U52', U51', U61', AND} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, ISNAT, ISNATILIST, ISNATLIST, ISNATKIND, ISNATILISTKIND, U} are not replacing on any position.

The ordinary context-sensitive dependency pairs DP_o are:

U21'(tt, V1) → U22'(isNat(V1))
U21'(tt, V1) → ISNAT(V1)
U41'(tt, V1, V2) → U42'(isNat(V1), V2)
U41'(tt, V1, V2) → ISNAT(V1)
U42'(tt, V2) → U43'(isNatIList(V2))
U42'(tt, V2) → ISNATILIST(V2)
U51'(tt, V1, V2) → U52'(isNat(V1), V2)
U51'(tt, V1, V2) → ISNAT(V1)
U52'(tt, V2) → U53'(isNatList(V2))
U52'(tt, V2) → ISNATLIST(V2)
U61'(tt, L) → LENGTH(L)
ISNAT(s(V1)) → U21'(isNatKind(V1), V1)
ISNAT(s(V1)) → ISNATKIND(V1)
ISNATILIST(cons(V1, V2)) → U41'(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
ISNATILIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILIST(cons(V1, V2)) → ISNATKIND(V1)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)
ISNATLIST(cons(V1, V2)) → U51'(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
ISNATLIST(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
ISNATLIST(cons(V1, V2)) → ISNATKIND(V1)
LENGTH(cons(N, L)) → U61'(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
LENGTH(cons(N, L)) → AND(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
LENGTH(cons(N, L)) → AND(isNatList(L), isNatIListKind(L))
LENGTH(cons(N, L)) → ISNATLIST(L)

The collapsing dependency pairs are DP_c:

U61'(tt, L) → L
AND(tt, X) → X

The hidden terms of R are:

zeros
isNatIListKind(x0)
and(isNat(x0), isNatKind(x0))
isNat(x0)
isNatKind(x0)

Every hiding context is built from:

and on positions {1}

Hence, the new unhiding pairs DP_u are :

U61'(tt, L) → U(L)
AND(tt, X) → U(X)
U(and(x_0, x_1)) → U(x_0)
U(zeros) → ZEROS
U(isNatIListKind(x0)) → ISNATILISTKIND(x0)
U(and(isNat(x0), isNatKind(x0))) → AND(isNat(x0), isNatKind(x0))
U(isNat(x0)) → ISNAT(x0)
U(isNatKind(x0)) → ISNATKIND(x0)

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(21) QCSDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Context-Sensitive Dependency Graph [LPAR08] contains 4 SCCs with 14 less nodes.

(22) Complex Obligation (AND)

(23) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, U21', AND} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, ISNAT, ISNATKIND, ISNATILISTKIND, U} are not replacing on any position.

The TRS P consists of the following rules:

ISNAT(s(V1)) → U21'(isNatKind(V1), V1)
U21'(tt, V1) → ISNAT(V1)
ISNAT(s(V1)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(x0)) → ISNATILISTKIND(x0)
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)
U(and(isNat(x0), isNatKind(x0))) → AND(isNat(x0), isNatKind(x0))
U(isNat(x0)) → ISNAT(x0)
U(isNatKind(x0)) → ISNATKIND(x0)

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(24) QCSDPReductionPairProof (EQUIVALENT transformation)

Using the order
Polynomial interpretation with max and min functions [POLO,MAXPOLO]:

POL(0) = 0   
POL(AND(x₁, x₂)) = x₂   
POL(ISNAT(x₁)) = 0   
POL(ISNATILISTKIND(x₁)) = 0   
POL(ISNATKIND(x₁)) = 0   
POL(U(x₁)) = x₁   
POL(U21(x₁, x₂)) = 1   
POL(U21'(x₁, x₂)) = 0   
POL(U22(x₁)) = 0   
POL(U51(x₁, x₂, x₃)) = 0   
POL(U52(x₁, x₂)) = 0   
POL(U53(x₁)) = 0   
POL(U61(x₁, x₂)) = 0   
POL(and(x₁, x₂)) = x₁ + x₂   
POL(cons(x₁, x₂)) = 0   
POL(isNat(x₁)) = 1 + x₁   
POL(isNatIListKind(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatList(x₁)) = 0   
POL(length(x₁)) = 0   
POL(nil) = 0   
POL(s(x₁)) = 0   
POL(tt) = 0   
POL(zeros) = 0   

the following usable rules

isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U61(tt, L) → s(length(L))
and(tt, X) → X
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
zeros → cons(0, zeros)

could all be oriented weakly.
Furthermore, the pairs

U(and(isNat(x0), isNatKind(x0))) → AND(isNat(x0), isNatKind(x0))
U(isNat(x0)) → ISNAT(x0)

could be oriented strictly and thus removed by the CS-Reduction Pair Processor [LPAR08,DA_EMMES].

(25) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, U21', AND} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, ISNAT, ISNATKIND, ISNATILISTKIND, U} are not replacing on any position.

The TRS P consists of the following rules:

ISNAT(s(V1)) → U21'(isNatKind(V1), V1)
U21'(tt, V1) → ISNAT(V1)
ISNAT(s(V1)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(x0)) → ISNATILISTKIND(x0)
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)
U(isNatKind(x0)) → ISNATKIND(x0)

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(26) QCSDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Context-Sensitive Dependency Graph [LPAR08] contains 2 SCCs with 1 less node.

(27) Complex Obligation (AND)

(28) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, AND} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, ISNATILISTKIND, U, ISNATKIND} are not replacing on any position.

The TRS P consists of the following rules:

ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(x0)) → ISNATILISTKIND(x0)
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(length(V1)) → ISNATILISTKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)
U(isNatKind(x0)) → ISNATKIND(x0)

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(29) QCSDPReductionPairProof (EQUIVALENT transformation)

Using the order
Polynomial interpretation with max and min functions [POLO,MAXPOLO]:

POL(0) = 0   
POL(AND(x₁, x₂)) = x₂   
POL(ISNATILISTKIND(x₁)) = x₁   
POL(ISNATKIND(x₁)) = x₁   
POL(U(x₁)) = x₁   
POL(U21(x₁, x₂)) = 0   
POL(U22(x₁)) = 0   
POL(U51(x₁, x₂, x₃)) = 1 + x₃   
POL(U52(x₁, x₂)) = 0   
POL(U53(x₁)) = 0   
POL(U61(x₁, x₂)) = 1 + x₂   
POL(and(x₁, x₂)) = x₁ + x₂   
POL(cons(x₁, x₂)) = x₁ + x₂   
POL(isNat(x₁)) = x₁   
POL(isNatIListKind(x₁)) = x₁   
POL(isNatKind(x₁)) = x₁   
POL(isNatList(x₁)) = 1 + x₁   
POL(length(x₁)) = 1 + x₁   
POL(nil) = 1   
POL(s(x₁)) = x₁   
POL(tt) = 0   
POL(zeros) = 0   

the following usable rules

isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U61(tt, L) → s(length(L))
and(tt, X) → X
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
zeros → cons(0, zeros)

could all be oriented weakly.
Furthermore, the pairs

ISNATKIND(length(V1)) → ISNATILISTKIND(V1)

could be oriented strictly and thus removed by the CS-Reduction Pair Processor [LPAR08,DA_EMMES].

(30) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, AND} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, ISNATILISTKIND, U, ISNATKIND} are not replacing on any position.

The TRS P consists of the following rules:

ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, X) → U(X)
U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(x0)) → ISNATILISTKIND(x0)
ISNATILISTKIND(cons(V1, V2)) → ISNATKIND(V1)
ISNATKIND(s(V1)) → ISNATKIND(V1)
U(isNatKind(x0)) → ISNATKIND(x0)

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(31) QCSDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Context-Sensitive Dependency Graph [LPAR08] contains 2 SCCs with 2 less nodes.

(32) Complex Obligation (AND)

(33) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, ISNATKIND} are not replacing on any position.

The TRS P consists of the following rules:

ISNATKIND(s(V1)) → ISNATKIND(V1)

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(34) QCSDPSubtermProof (EQUIVALENT transformation)

We use the subterm processor [DA_EMMES].

The following pairs can be oriented strictly and are deleted.

ISNATKIND(s(V1)) → ISNATKIND(V1)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
ISNATKIND(x1)  =  x1

Subterm Order

(35) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind} are not replacing on any position.

The TRS P consists of the following rules:
none

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(36) PIsEmptyProof (EQUIVALENT transformation)

The TRS P is empty. Hence, there is no (P,Q,R,µ)-chain.

(37) TRUE

(38) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, AND} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, U, ISNATILISTKIND} are not replacing on any position.

The TRS P consists of the following rules:

AND(tt, X) → U(X)
U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(x0)) → ISNATILISTKIND(x0)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(39) QCSDPInstantiationProcessor (EQUIVALENT transformation)

Using the Context-Sensitive Instantiation[LPAR08,DA_EMMES] Processor
the pair AND(tt, X) → U(X)
was transformed to the following new pairs:

AND(tt, isNatIListKind(z1)) → U(isNatIListKind(z1))

(40) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, AND} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, U, ISNATILISTKIND} are not replacing on any position.

The TRS P consists of the following rules:

U(and(x_0, x_1)) → U(x_0)
U(isNatIListKind(x0)) → ISNATILISTKIND(x0)
ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, isNatIListKind(z1)) → U(isNatIListKind(z1))

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(41) QCSDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Context-Sensitive Dependency Graph [LPAR08] contains 2 SCCs.
The rules AND(tt, isNatIListKind(z0)) → U(isNatIListKind(z0)) and U(and(x0, x1)) → U(x0) form no chain, because ECap^µ(U(isNatIListKind(z0))) = U(isNatIListKind(z0)) does not unify with U(and(x0, x1)).

(42) Complex Obligation (AND)

(43) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, AND} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, ISNATILISTKIND, U} are not replacing on any position.

The TRS P consists of the following rules:

ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, isNatIListKind(z1)) → U(isNatIListKind(z1))
U(isNatIListKind(x0)) → ISNATILISTKIND(x0)

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(44) QCSDPForwardInstantiationProcessor (EQUIVALENT transformation)

Using the Context-Sensitive Forward Instantiation[DA_EMMES] Processor
the pair U(isNatIListKind(x0)) → ISNATILISTKIND(x0)
was transformed to the following new pairs:

U(isNatIListKind(cons(z0, z1))) → ISNATILISTKIND(cons(z0, z1))

(45) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, AND} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, ISNATILISTKIND, U} are not replacing on any position.

The TRS P consists of the following rules:

ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
AND(tt, isNatIListKind(z1)) → U(isNatIListKind(z1))
U(isNatIListKind(cons(z0, z1))) → ISNATILISTKIND(cons(z0, z1))

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(46) QCSDPForwardInstantiationProcessor (EQUIVALENT transformation)

Using the Context-Sensitive Forward Instantiation[DA_EMMES] Processor
the pair AND(tt, isNatIListKind(z1)) → U(isNatIListKind(z1))
was transformed to the following new pairs:

AND(tt, isNatIListKind(cons(z0, z1))) → U(isNatIListKind(cons(z0, z1)))

(47) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, AND} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, ISNATILISTKIND, U} are not replacing on any position.

The TRS P consists of the following rules:

ISNATILISTKIND(cons(V1, V2)) → AND(isNatKind(V1), isNatIListKind(V2))
U(isNatIListKind(cons(z0, z1))) → ISNATILISTKIND(cons(z0, z1))
AND(tt, isNatIListKind(cons(z0, z1))) → U(isNatIListKind(cons(z0, z1)))

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(48) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, U} are not replacing on any position.

The TRS P consists of the following rules:

U(and(x_0, x_1)) → U(x_0)

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(49) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, U21'} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, ISNAT} are not replacing on any position.

The TRS P consists of the following rules:

U21'(tt, V1) → ISNAT(V1)
ISNAT(s(V1)) → U21'(isNatKind(V1), V1)

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(50) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, U52', U51'} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, ISNATLIST} are not replacing on any position.

The TRS P consists of the following rules:

U51'(tt, V1, V2) → U52'(isNat(V1), V2)
U52'(tt, V2) → ISNATLIST(V2)
ISNATLIST(cons(V1, V2)) → U51'(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(51) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length, LENGTH} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, U61'} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind} are not replacing on any position.

The TRS P consists of the following rules:

LENGTH(cons(N, L)) → U61'(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U61'(tt, L) → LENGTH(L)

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(52) Obligation:

Q-restricted context-sensitive dependency pair problem:
The symbols in {U22, U43, U53, s, length} are replacing on all positions.
For all symbols f in {cons, U21, U41, U42, U51, U52, U61, and, U42', U41'} we have µ(f) = {1}.
The symbols in {isNat, isNatIList, isNatList, isNatKind, isNatIListKind, ISNATILIST} are not replacing on any position.

The TRS P consists of the following rules:

U41'(tt, V1, V2) → U42'(isNat(V1), V2)
U42'(tt, V2) → ISNATILIST(V2)
ISNATILIST(cons(V1, V2)) → U41'(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)

The TRS R consists of the following rules:

zeros → cons(0, zeros)
U21(tt, V1) → U22(isNat(V1))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(V1), V2)
U42(tt, V2) → U43(isNatIList(V2))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(V1), V2)
U52(tt, V2) → U53(isNatList(V2))
U53(tt) → tt
U61(tt, L) → s(length(L))
and(tt, X) → X
isNat(0) → tt
isNat(s(V1)) → U21(isNatKind(V1), V1)
isNatIList(cons(V1, V2)) → U41(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
isNatIListKind(nil) → tt
isNatIListKind(zeros) → tt
isNatIListKind(cons(V1, V2)) → and(isNatKind(V1), isNatIListKind(V2))
isNatKind(0) → tt
isNatKind(length(V1)) → isNatIListKind(V1)
isNatKind(s(V1)) → isNatKind(V1)
isNatList(cons(V1, V2)) → U51(and(isNatKind(V1), isNatIListKind(V2)), V1, V2)
length(cons(N, L)) → U61(and(and(isNatList(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(53) Zantema-Transformation (SOUND transformation)

We applied the Zantema transformation [CS_Zan] to transform the context-sensitive TRS to a usual TRS.

(54) Obligation:

Q restricted rewrite system:
The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.

(55) DependencyPairsProof (EQUIVALENT transformation)

Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.

(56) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ZEROS → CONS(0, zerosInact)
ZEROS → 0¹
U21¹(tt, V1) → U22¹(isNat(a(V1)))
U21¹(tt, V1) → ISNAT(a(V1))
U21¹(tt, V1) → A(V1)
U41¹(tt, V1, V2) → U42¹(isNat(a(V1)), a(V2))
U41¹(tt, V1, V2) → ISNAT(a(V1))
U41¹(tt, V1, V2) → A(V1)
U41¹(tt, V1, V2) → A(V2)
U42¹(tt, V2) → U43¹(isNatIList(a(V2)))
U42¹(tt, V2) → ISNATILIST(a(V2))
U42¹(tt, V2) → A(V2)
U51¹(tt, V1, V2) → U52¹(isNat(a(V1)), a(V2))
U51¹(tt, V1, V2) → ISNAT(a(V1))
U51¹(tt, V1, V2) → A(V1)
U51¹(tt, V1, V2) → A(V2)
U52¹(tt, V2) → U53¹(isNatList(a(V2)))
U52¹(tt, V2) → ISNATLIST(a(V2))
U52¹(tt, V2) → A(V2)
U61¹(tt, L) → S(length(a(L)))
U61¹(tt, L) → LENGTH(a(L))
U61¹(tt, L) → A(L)
AND(tt, X) → A(X)
ISNAT(sInact(V1)) → U21¹(isNatKind(a(V1)), a(V1))
ISNAT(sInact(V1)) → ISNATKIND(a(V1))
ISNAT(sInact(V1)) → A(V1)
ISNATILIST(consInact(V1, V2)) → U41¹(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
ISNATILIST(consInact(V1, V2)) → AND(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
ISNATILIST(consInact(V1, V2)) → ISNATKIND(a(V1))
ISNATILIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNATILISTKIND(consInact(V1, V2)) → AND(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
ISNATILISTKIND(consInact(V1, V2)) → ISNATKIND(a(V1))
ISNATILISTKIND(consInact(V1, V2)) → A(V1)
ISNATILISTKIND(consInact(V1, V2)) → A(V2)
ISNATKIND(lengthInact(V1)) → ISNATILISTKIND(a(V1))
ISNATKIND(lengthInact(V1)) → A(V1)
ISNATKIND(sInact(V1)) → ISNATKIND(a(V1))
ISNATKIND(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → U51¹(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
ISNATLIST(consInact(V1, V2)) → AND(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
ISNATLIST(consInact(V1, V2)) → ISNATKIND(a(V1))
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATLIST(consInact(V1, V2)) → A(V2)
LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
LENGTH(cons(N, L)) → AND(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N)))
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatIListKindInact(a(L)))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
LENGTH(cons(N, L)) → A(L)
LENGTH(cons(N, L)) → ISNAT(N)
A(zerosInact) → ZEROS
A(0Inact) → 0¹
A(sInact(x1)) → S(x1)
A(consInact(x1, x2)) → CONS(x1, x2)
A(isNatIListKindInact(x1)) → ISNATILISTKIND(x1)
A(nilInact) → NIL
A(lengthInact(x1)) → LENGTH(x1)
A(andInact(x1, x2)) → AND(x1, x2)
A(isNatKindInact(x1)) → ISNATKIND(x1)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(57) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs with 19 less nodes.

(58) Complex Obligation (AND)

(59) Obligation:

Q DP problem:
The TRS P consists of the following rules:

A(isNatIListKindInact(x1)) → ISNATILISTKIND(x1)
ISNATILISTKIND(consInact(V1, V2)) → AND(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
AND(tt, X) → A(X)
A(lengthInact(x1)) → LENGTH(x1)
LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, L) → LENGTH(a(L))
LENGTH(cons(N, L)) → AND(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N)))
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatIListKindInact(a(L)))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNATLIST(consInact(V1, V2)) → U51¹(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
U51¹(tt, V1, V2) → U52¹(isNat(a(V1)), a(V2))
U52¹(tt, V2) → ISNATLIST(a(V2))
ISNATLIST(consInact(V1, V2)) → AND(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
ISNATLIST(consInact(V1, V2)) → ISNATKIND(a(V1))
ISNATKIND(lengthInact(V1)) → ISNATILISTKIND(a(V1))
ISNATILISTKIND(consInact(V1, V2)) → ISNATKIND(a(V1))
ISNATKIND(lengthInact(V1)) → A(V1)
A(andInact(x1, x2)) → AND(x1, x2)
A(isNatKindInact(x1)) → ISNATKIND(x1)
ISNATKIND(sInact(V1)) → ISNATKIND(a(V1))
ISNATKIND(sInact(V1)) → A(V1)
ISNATILISTKIND(consInact(V1, V2)) → A(V1)
ISNATILISTKIND(consInact(V1, V2)) → A(V2)
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATLIST(consInact(V1, V2)) → A(V2)
U52¹(tt, V2) → A(V2)
U51¹(tt, V1, V2) → ISNAT(a(V1))
ISNAT(sInact(V1)) → U21¹(isNatKind(a(V1)), a(V1))
U21¹(tt, V1) → ISNAT(a(V1))
ISNAT(sInact(V1)) → ISNATKIND(a(V1))
ISNAT(sInact(V1)) → A(V1)
U21¹(tt, V1) → A(V1)
U51¹(tt, V1, V2) → A(V1)
U51¹(tt, V1, V2) → A(V2)
LENGTH(cons(N, L)) → A(L)
LENGTH(cons(N, L)) → ISNAT(N)
U61¹(tt, L) → A(L)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(60) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

LENGTH(cons(N, L)) → AND(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N)))
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatIListKindInact(a(L)))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNATKIND(lengthInact(V1)) → ISNATILISTKIND(a(V1))
ISNATKIND(lengthInact(V1)) → A(V1)
LENGTH(cons(N, L)) → A(L)
LENGTH(cons(N, L)) → ISNAT(N)
U61¹(tt, L) → A(L)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(0Inact) = 0   
POL(A(x₁)) = x₁   
POL(AND(x₁, x₂)) = x₂   
POL(ISNAT(x₁)) = x₁   
POL(ISNATILISTKIND(x₁)) = x₁   
POL(ISNATKIND(x₁)) = x₁   
POL(ISNATLIST(x₁)) = x₁   
POL(LENGTH(x₁)) = 1 + x₁   
POL(U21(x₁, x₂)) = 0   
POL(U21¹(x₁, x₂)) = x₂   
POL(U22(x₁)) = 0   
POL(U51(x₁, x₂, x₃)) = 0   
POL(U51¹(x₁, x₂, x₃)) = x₂ + x₃   
POL(U52(x₁, x₂)) = 0   
POL(U52¹(x₁, x₂)) = x₂   
POL(U53(x₁)) = 0   
POL(U61(x₁, x₂)) = 1 + x₁ + x₂   
POL(U61¹(x₁, x₂)) = 1 + x₂   
POL(a(x₁)) = x₁   
POL(and(x₁, x₂)) = x₂   
POL(andInact(x₁, x₂)) = x₂   
POL(cons(x₁, x₂)) = x₁ + x₂   
POL(consInact(x₁, x₂)) = x₁ + x₂   
POL(isNat(x₁)) = 0   
POL(isNatIListKind(x₁)) = x₁   
POL(isNatIListKindInact(x₁)) = x₁   
POL(isNatKind(x₁)) = x₁   
POL(isNatKindInact(x₁)) = x₁   
POL(isNatList(x₁)) = 0   
POL(length(x₁)) = 1 + x₁   
POL(lengthInact(x₁)) = 1 + x₁   
POL(nil) = 1   
POL(nilInact) = 1   
POL(s(x₁)) = x₁   
POL(sInact(x₁)) = x₁   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosInact) = 0   

The following usable rules [FROCOS05] were oriented:

zeros → cons(0, zerosInact)
U22(tt) → tt
U21(tt, V1) → U22(isNat(a(V1)))
U53(tt) → tt
U52(tt, V2) → U53(isNatList(a(V2)))
U61(tt, L) → s(length(a(L)))
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
isNatIListKind(zerosInact) → tt
isNatKind(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIListKind(nilInact) → tt
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
a(nilInact) → nil
nil → nilInact
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
a(isNatKindInact(x1)) → isNatKind(x1)
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
a(andInact(x1, x2)) → and(x1, x2)
and(tt, X) → a(X)
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatIListKind(x1) → isNatIListKindInact(x1)
a(consInact(x1, x2)) → cons(x1, x2)
cons(x1, x2) → consInact(x1, x2)
a(sInact(x1)) → s(x1)
s(x1) → sInact(x1)
isNatKind(x1) → isNatKindInact(x1)
and(x1, x2) → andInact(x1, x2)
a(lengthInact(x1)) → length(x1)
length(x1) → lengthInact(x1)

(61) Obligation:

Q DP problem:
The TRS P consists of the following rules:

A(isNatIListKindInact(x1)) → ISNATILISTKIND(x1)
ISNATILISTKIND(consInact(V1, V2)) → AND(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
AND(tt, X) → A(X)
A(lengthInact(x1)) → LENGTH(x1)
LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, L) → LENGTH(a(L))
ISNATLIST(consInact(V1, V2)) → U51¹(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
U51¹(tt, V1, V2) → U52¹(isNat(a(V1)), a(V2))
U52¹(tt, V2) → ISNATLIST(a(V2))
ISNATLIST(consInact(V1, V2)) → AND(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
ISNATLIST(consInact(V1, V2)) → ISNATKIND(a(V1))
ISNATILISTKIND(consInact(V1, V2)) → ISNATKIND(a(V1))
A(andInact(x1, x2)) → AND(x1, x2)
A(isNatKindInact(x1)) → ISNATKIND(x1)
ISNATKIND(sInact(V1)) → ISNATKIND(a(V1))
ISNATKIND(sInact(V1)) → A(V1)
ISNATILISTKIND(consInact(V1, V2)) → A(V1)
ISNATILISTKIND(consInact(V1, V2)) → A(V2)
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATLIST(consInact(V1, V2)) → A(V2)
U52¹(tt, V2) → A(V2)
U51¹(tt, V1, V2) → ISNAT(a(V1))
ISNAT(sInact(V1)) → U21¹(isNatKind(a(V1)), a(V1))
U21¹(tt, V1) → ISNAT(a(V1))
ISNAT(sInact(V1)) → ISNATKIND(a(V1))
ISNAT(sInact(V1)) → A(V1)
U21¹(tt, V1) → A(V1)
U51¹(tt, V1, V2) → A(V1)
U51¹(tt, V1, V2) → A(V2)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(62) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 4 SCCs with 12 less nodes.

(63) Complex Obligation (AND)

(64) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U61¹(tt, L) → LENGTH(a(L))
LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(65) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule U61¹(tt, L) → LENGTH(a(L)) at position [0] we obtained the following new rules [LPAR04]:

U61¹(tt, x0) → LENGTH(x0)
U61¹(tt, zerosInact) → LENGTH(zeros)
U61¹(tt, 0Inact) → LENGTH(0)
U61¹(tt, sInact(x0)) → LENGTH(s(x0))
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))
U61¹(tt, nilInact) → LENGTH(nil)
U61¹(tt, lengthInact(x0)) → LENGTH(length(x0))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, isNatKindInact(x0)) → LENGTH(isNatKind(x0))

(66) Obligation:

Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, x0) → LENGTH(x0)
U61¹(tt, zerosInact) → LENGTH(zeros)
U61¹(tt, 0Inact) → LENGTH(0)
U61¹(tt, sInact(x0)) → LENGTH(s(x0))
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))
U61¹(tt, nilInact) → LENGTH(nil)
U61¹(tt, lengthInact(x0)) → LENGTH(length(x0))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, isNatKindInact(x0)) → LENGTH(isNatKind(x0))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(67) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule U61¹(tt, zerosInact) → LENGTH(zeros) at position [0] we obtained the following new rules [LPAR04]:

U61¹(tt, zerosInact) → LENGTH(cons(0, zerosInact))
U61¹(tt, zerosInact) → LENGTH(zerosInact)

(68) Obligation:

Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, x0) → LENGTH(x0)
U61¹(tt, 0Inact) → LENGTH(0)
U61¹(tt, sInact(x0)) → LENGTH(s(x0))
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))
U61¹(tt, nilInact) → LENGTH(nil)
U61¹(tt, lengthInact(x0)) → LENGTH(length(x0))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, isNatKindInact(x0)) → LENGTH(isNatKind(x0))
U61¹(tt, zerosInact) → LENGTH(cons(0, zerosInact))
U61¹(tt, zerosInact) → LENGTH(zerosInact)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(69) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(70) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U61¹(tt, x0) → LENGTH(x0)
LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, 0Inact) → LENGTH(0)
U61¹(tt, sInact(x0)) → LENGTH(s(x0))
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))
U61¹(tt, nilInact) → LENGTH(nil)
U61¹(tt, lengthInact(x0)) → LENGTH(length(x0))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, isNatKindInact(x0)) → LENGTH(isNatKind(x0))
U61¹(tt, zerosInact) → LENGTH(cons(0, zerosInact))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(71) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule U61¹(tt, 0Inact) → LENGTH(0) at position [0] we obtained the following new rules [LPAR04]:

U61¹(tt, 0Inact) → LENGTH(0Inact)

(72) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U61¹(tt, x0) → LENGTH(x0)
LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, sInact(x0)) → LENGTH(s(x0))
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))
U61¹(tt, nilInact) → LENGTH(nil)
U61¹(tt, lengthInact(x0)) → LENGTH(length(x0))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, isNatKindInact(x0)) → LENGTH(isNatKind(x0))
U61¹(tt, zerosInact) → LENGTH(cons(0, zerosInact))
U61¹(tt, 0Inact) → LENGTH(0Inact)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(73) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(74) Obligation:

Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, x0) → LENGTH(x0)
U61¹(tt, sInact(x0)) → LENGTH(s(x0))
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))
U61¹(tt, nilInact) → LENGTH(nil)
U61¹(tt, lengthInact(x0)) → LENGTH(length(x0))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, isNatKindInact(x0)) → LENGTH(isNatKind(x0))
U61¹(tt, zerosInact) → LENGTH(cons(0, zerosInact))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(75) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule U61¹(tt, sInact(x0)) → LENGTH(s(x0)) at position [0] we obtained the following new rules [LPAR04]:

U61¹(tt, sInact(x0)) → LENGTH(sInact(x0))

(76) Obligation:

Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, x0) → LENGTH(x0)
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))
U61¹(tt, nilInact) → LENGTH(nil)
U61¹(tt, lengthInact(x0)) → LENGTH(length(x0))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, isNatKindInact(x0)) → LENGTH(isNatKind(x0))
U61¹(tt, zerosInact) → LENGTH(cons(0, zerosInact))
U61¹(tt, sInact(x0)) → LENGTH(sInact(x0))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(77) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(78) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U61¹(tt, x0) → LENGTH(x0)
LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))
U61¹(tt, nilInact) → LENGTH(nil)
U61¹(tt, lengthInact(x0)) → LENGTH(length(x0))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, isNatKindInact(x0)) → LENGTH(isNatKind(x0))
U61¹(tt, zerosInact) → LENGTH(cons(0, zerosInact))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(79) Narrowing (EQUIVALENT transformation)

By narrowing [LPAR04] the rule U61¹(tt, nilInact) → LENGTH(nil) at position [0] we obtained the following new rules [LPAR04]:

U61¹(tt, nilInact) → LENGTH(nilInact)

(80) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U61¹(tt, x0) → LENGTH(x0)
LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))
U61¹(tt, lengthInact(x0)) → LENGTH(length(x0))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, isNatKindInact(x0)) → LENGTH(isNatKind(x0))
U61¹(tt, zerosInact) → LENGTH(cons(0, zerosInact))
U61¹(tt, nilInact) → LENGTH(nilInact)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(81) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

(82) Obligation:

Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, x0) → LENGTH(x0)
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))
U61¹(tt, lengthInact(x0)) → LENGTH(length(x0))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, isNatKindInact(x0)) → LENGTH(isNatKind(x0))
U61¹(tt, zerosInact) → LENGTH(cons(0, zerosInact))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(83) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U61¹(tt, isNatKindInact(x0)) → LENGTH(isNatKind(x0))

The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO]:

POL(LENGTH(x1)) =

/ 0 \ \ 0 /

+

/ 0 1 \ \ 0 0 /

·

x1

POL(cons(x1, x2)) =

/ 0 \ \ 0 /

+

/ 1 0 \ \ 0 0 /

·

x1

+

/ 0 0 \ \ 1 1 /

·

x2

POL(U611(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 1 1 \ \ 0 0 /

·

x2

POL(and(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 1 \ \ 0 0 /

·

x1

+

/ 1 0 \ \ 0 1 /

·

x2

POL(isNatList(x1)) =

/ 0 \ \ 0 /

+

/ 1 0 \ \ 0 0 /

·

x1

POL(a(x1)) =

/ 0 \ \ 0 /

+

/ 1 0 \ \ 0 1 /

·

x1

POL(isNatIListKindInact(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(andInact(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 1 \ \ 0 0 /

·

x1

+

/ 1 0 \ \ 0 1 /

·

x2

POL(isNat(x1)) =

/ 0 \ \ 1 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(isNatKindInact(x1)) =

/ 1 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(tt) =

/ 0 \ \ 0 /

POL(consInact(x1, x2)) =

/ 0 \ \ 0 /

+

/ 1 0 \ \ 0 0 /

·

x1

+

/ 0 0 \ \ 1 1 /

·

x2

POL(isNatIListKind(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(lengthInact(x1)) =

/ 0 \ \ 0 /

+

/ 1 0 \ \ 0 0 /

·

x1

POL(length(x1)) =

/ 0 \ \ 0 /

+

/ 1 0 \ \ 0 0 /

·

x1

POL(isNatKind(x1)) =

/ 1 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(zerosInact) =

/ 0 \ \ 0 /

POL(0) =

/ 0 \ \ 0 /

POL(zeros) =

/ 0 \ \ 0 /

POL(U22(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(U21(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 0 0 \ \ 0 0 /

·

x2

POL(U53(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(U52(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 1 0 /

·

x1

+

/ 0 0 \ \ 0 0 /

·

x2

POL(U61(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 0 0 \ \ 0 0 /

·

x2

POL(s(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(U51(x1, x2, x3)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 0 0 \ \ 0 0 /

·

x2

+

/ 0 0 \ \ 0 0 /

·

x3

POL(0Inact) =

/ 0 \ \ 0 /

POL(sInact(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(nilInact) =

/ 1 \ \ 1 /

POL(nil) =

/ 1 \ \ 1 /

The following usable rules [FROCOS05] were oriented:

zeros → cons(0, zerosInact)
U22(tt) → tt
U21(tt, V1) → U22(isNat(a(V1)))
U53(tt) → tt
U52(tt, V2) → U53(isNatList(a(V2)))
U61(tt, L) → s(length(a(L)))
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
isNatIListKind(zerosInact) → tt
isNatKind(0Inact) → tt
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIListKind(nilInact) → tt
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
a(nilInact) → nil
nil → nilInact
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
a(isNatKindInact(x1)) → isNatKind(x1)
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
a(andInact(x1, x2)) → and(x1, x2)
and(tt, X) → a(X)
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatIListKind(x1) → isNatIListKindInact(x1)
a(consInact(x1, x2)) → cons(x1, x2)
cons(x1, x2) → consInact(x1, x2)
a(sInact(x1)) → s(x1)
s(x1) → sInact(x1)
isNatKind(x1) → isNatKindInact(x1)
and(x1, x2) → andInact(x1, x2)
a(lengthInact(x1)) → length(x1)
length(x1) → lengthInact(x1)

(84) Obligation:

Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, x0) → LENGTH(x0)
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))
U61¹(tt, lengthInact(x0)) → LENGTH(length(x0))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, zerosInact) → LENGTH(cons(0, zerosInact))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(85) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U61¹(tt, lengthInact(x0)) → LENGTH(length(x0))

The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO]:

POL(LENGTH(x1)) =

/ 0 \ \ 0 /

+

/ 1 0 \ \ 0 0 /

·

x1

POL(cons(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 1 /

·

x1

+

/ 1 1 \ \ 1 0 /

·

x2

POL(U611(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 1 1 \ \ 0 0 /

·

x2

POL(and(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 1 0 \ \ 0 1 /

·

x2

POL(isNatList(x1)) =

/ 1 \ \ 1 /

+

/ 0 1 \ \ 1 1 /

·

x1

POL(a(x1)) =

/ 0 \ \ 0 /

+

/ 1 0 \ \ 0 1 /

·

x1

POL(isNatIListKindInact(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(andInact(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 1 0 \ \ 0 1 /

·

x2

POL(isNat(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 1 /

·

x1

POL(isNatKindInact(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(tt) =

/ 0 \ \ 0 /

POL(consInact(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 1 /

·

x1

+

/ 1 1 \ \ 1 0 /

·

x2

POL(isNatIListKind(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(lengthInact(x1)) =

/ 0 \ \ 1 /

+

/ 0 1 \ \ 0 0 /

·

x1

POL(length(x1)) =

/ 0 \ \ 1 /

+

/ 0 1 \ \ 0 0 /

·

x1

POL(zerosInact) =

/ 0 \ \ 0 /

POL(0) =

/ 0 \ \ 0 /

POL(zeros) =

/ 0 \ \ 0 /

POL(U22(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 1 0 /

·

x1

POL(U21(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 0 0 \ \ 0 0 /

·

x2

POL(U53(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(U52(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 0 0 \ \ 0 0 /

·

x2

POL(U61(x1, x2)) =

/ 0 \ \ 1 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 0 0 \ \ 0 0 /

·

x2

POL(s(x1)) =

/ 0 \ \ 1 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(U51(x1, x2, x3)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 0 1 \ \ 0 0 /

·

x2

+

/ 1 0 \ \ 1 0 /

·

x3

POL(isNatKind(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(0Inact) =

/ 0 \ \ 0 /

POL(sInact(x1)) =

/ 0 \ \ 1 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(nilInact) =

/ 0 \ \ 0 /

POL(nil) =

/ 0 \ \ 0 /

The following usable rules [FROCOS05] were oriented:

zeros → cons(0, zerosInact)
U22(tt) → tt
U21(tt, V1) → U22(isNat(a(V1)))
U53(tt) → tt
U52(tt, V2) → U53(isNatList(a(V2)))
U61(tt, L) → s(length(a(L)))
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
isNatIListKind(zerosInact) → tt
isNatKind(0Inact) → tt
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIListKind(nilInact) → tt
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
a(nilInact) → nil
nil → nilInact
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
a(isNatKindInact(x1)) → isNatKind(x1)
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
a(andInact(x1, x2)) → and(x1, x2)
and(tt, X) → a(X)
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatIListKind(x1) → isNatIListKindInact(x1)
a(consInact(x1, x2)) → cons(x1, x2)
cons(x1, x2) → consInact(x1, x2)
a(sInact(x1)) → s(x1)
s(x1) → sInact(x1)
isNatKind(x1) → isNatKindInact(x1)
and(x1, x2) → andInact(x1, x2)
a(lengthInact(x1)) → length(x1)
length(x1) → lengthInact(x1)

(86) Obligation:

Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, x0) → LENGTH(x0)
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, zerosInact) → LENGTH(cons(0, zerosInact))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(87) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U61¹(tt, isNatIListKindInact(x0)) → LENGTH(isNatIListKind(x0))

The remaining pairs can at least be oriented weakly.
Used ordering: Matrix interpretation [MATRO]:

POL(LENGTH(x1)) =

/ 0 \ \ 0 /

+

/ 1 0 \ \ 0 0 /

·

x1

POL(cons(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 1 1 \ \ 0 0 /

·

x2

POL(U611(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 1 1 \ \ 0 0 /

·

x2

POL(and(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 1 0 \ \ 0 1 /

·

x2

POL(isNatList(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(a(x1)) =

/ 0 \ \ 0 /

+

/ 1 0 \ \ 0 1 /

·

x1

POL(isNatIListKindInact(x1)) =

/ 0 \ \ 1 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(andInact(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 1 0 \ \ 0 1 /

·

x2

POL(isNat(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 1 0 /

·

x1

POL(isNatKindInact(x1)) =

/ 0 \ \ 1 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(tt) =

/ 0 \ \ 0 /

POL(consInact(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 1 1 \ \ 0 0 /

·

x2

POL(isNatIListKind(x1)) =

/ 0 \ \ 1 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(zerosInact) =

/ 0 \ \ 0 /

POL(0) =

/ 1 \ \ 0 /

POL(zeros) =

/ 0 \ \ 0 /

POL(U22(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(U21(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 0 0 \ \ 0 0 /

·

x2

POL(U53(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(U52(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 0 0 \ \ 0 0 /

·

x2

POL(U61(x1, x2)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 0 0 \ \ 0 0 /

·

x2

POL(s(x1)) =

/ 0 \ \ 0 /

+

/ 1 0 \ \ 0 0 /

·

x1

POL(length(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(U51(x1, x2, x3)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

+

/ 0 0 \ \ 0 0 /

·

x2

+

/ 0 0 \ \ 0 0 /

·

x3

POL(isNatKind(x1)) =

/ 0 \ \ 1 /

+

/ 0 0 \ \ 0 0 /

·

x1

POL(0Inact) =

/ 1 \ \ 0 /

POL(sInact(x1)) =

/ 0 \ \ 0 /

+

/ 1 0 \ \ 0 0 /

·

x1

POL(nilInact) =

/ 0 \ \ 0 /

POL(nil) =

/ 0 \ \ 0 /

POL(lengthInact(x1)) =

/ 0 \ \ 0 /

+

/ 0 0 \ \ 0 0 /

·

x1

The following usable rules [FROCOS05] were oriented:

zeros → cons(0, zerosInact)
U22(tt) → tt
U21(tt, V1) → U22(isNat(a(V1)))
U53(tt) → tt
U52(tt, V2) → U53(isNatList(a(V2)))
U61(tt, L) → s(length(a(L)))
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
isNatIListKind(zerosInact) → tt
isNatKind(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIListKind(nilInact) → tt
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
a(nilInact) → nil
nil → nilInact
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
a(isNatKindInact(x1)) → isNatKind(x1)
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
a(andInact(x1, x2)) → and(x1, x2)
and(tt, X) → a(X)
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatIListKind(x1) → isNatIListKindInact(x1)
a(consInact(x1, x2)) → cons(x1, x2)
cons(x1, x2) → consInact(x1, x2)
a(sInact(x1)) → s(x1)
s(x1) → sInact(x1)
isNatKind(x1) → isNatKindInact(x1)
and(x1, x2) → andInact(x1, x2)
a(lengthInact(x1)) → length(x1)
length(x1) → lengthInact(x1)

(88) Obligation:

Q DP problem:
The TRS P consists of the following rules:

LENGTH(cons(N, L)) → U61¹(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
U61¹(tt, x0) → LENGTH(x0)
U61¹(tt, consInact(x0, x1)) → LENGTH(cons(x0, x1))
U61¹(tt, andInact(x0, x1)) → LENGTH(and(x0, x1))
U61¹(tt, zerosInact) → LENGTH(cons(0, zerosInact))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(89) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ISNATILISTKIND(consInact(V1, V2)) → AND(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
AND(tt, X) → A(X)
A(isNatIListKindInact(x1)) → ISNATILISTKIND(x1)
ISNATILISTKIND(consInact(V1, V2)) → ISNATKIND(a(V1))
ISNATKIND(sInact(V1)) → ISNATKIND(a(V1))
ISNATKIND(sInact(V1)) → A(V1)
A(andInact(x1, x2)) → AND(x1, x2)
A(isNatKindInact(x1)) → ISNATKIND(x1)
ISNATILISTKIND(consInact(V1, V2)) → A(V1)
ISNATILISTKIND(consInact(V1, V2)) → A(V2)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(90) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ISNAT(sInact(V1)) → U21¹(isNatKind(a(V1)), a(V1))
U21¹(tt, V1) → ISNAT(a(V1))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(91) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ISNATLIST(consInact(V1, V2)) → U51¹(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
U51¹(tt, V1, V2) → U52¹(isNat(a(V1)), a(V2))
U52¹(tt, V2) → ISNATLIST(a(V2))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(92) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U41¹(tt, V1, V2) → U42¹(isNat(a(V1)), a(V2))
U42¹(tt, V2) → ISNATILIST(a(V2))
ISNATILIST(consInact(V1, V2)) → U41¹(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U21(tt, V1) → U22(isNat(a(V1)))
U22(tt) → tt
U41(tt, V1, V2) → U42(isNat(a(V1)), a(V2))
U42(tt, V2) → U43(isNatIList(a(V2)))
U43(tt) → tt
U51(tt, V1, V2) → U52(isNat(a(V1)), a(V2))
U52(tt, V2) → U53(isNatList(a(V2)))
U53(tt) → tt
U61(tt, L) → s(length(a(L)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(sInact(V1)) → U21(isNatKind(a(V1)), a(V1))
isNatIList(consInact(V1, V2)) → U41(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
isNatIListKind(nilInact) → tt
isNatIListKind(zerosInact) → tt
isNatIListKind(consInact(V1, V2)) → and(isNatKind(a(V1)), isNatIListKindInact(a(V2)))
isNatKind(0Inact) → tt
isNatKind(lengthInact(V1)) → isNatIListKind(a(V1))
isNatKind(sInact(V1)) → isNatKind(a(V1))
isNatList(consInact(V1, V2)) → U51(and(isNatKind(a(V1)), isNatIListKindInact(a(V2))), a(V1), a(V2))
length(cons(N, L)) → U61(and(and(isNatList(a(L)), isNatIListKindInact(a(L))), andInact(isNat(N), isNatKindInact(N))), a(L))
a(x) → x
zeros → zerosInact
a(zerosInact) → zeros
0 → 0Inact
a(0Inact) → 0
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
isNatIListKind(x1) → isNatIListKindInact(x1)
a(isNatIListKindInact(x1)) → isNatIListKind(x1)
nil → nilInact
a(nilInact) → nil
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
isNatKind(x1) → isNatKindInact(x1)
a(isNatKindInact(x1)) → isNatKind(x1)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(93) Incomplete Giesl Middeldorp-Transformation (SOUND transformation)

We applied the Incomplete Giesl Middeldorp transformation [CS_Term] to transform the context-sensitive TRS to a usual TRS.

(94) Obligation:

Q restricted rewrite system:
The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.

(95) DependencyPairsProof (EQUIVALENT transformation)

Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.

(96) Obligation:

Q DP problem:
The TRS P consists of the following rules:

MARK(zeros) → ZEROSACTIVE
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U22(x1)) → U22ACTIVE(mark(x1))
MARK(U22(x1)) → MARK(x1)
MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
MARK(U41(x1, x2, x3)) → MARK(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(U42(x1, x2)) → MARK(x1)
MARK(U43(x1)) → U43ACTIVE(mark(x1))
MARK(U43(x1)) → MARK(x1)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
MARK(U52(x1, x2)) → MARK(x1)
MARK(U53(x1)) → U53ACTIVE(mark(x1))
MARK(U53(x1)) → MARK(x1)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
MARK(U61(x1, x2)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(and(x1, x2)) → MARK(x1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(length(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(s(x1)) → MARK(x1)
U21ACTIVE(tt, V1) → U22ACTIVE(isNatActive(V1))
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
U42ACTIVE(tt, V2) → U43ACTIVE(isNatIListActive(V2))
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
U52ACTIVE(tt, V2) → U53ACTIVE(isNatListActive(V2))
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
U61ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
U61ACTIVE(tt, L) → MARK(L)
ANDACTIVE(tt, X) → MARK(X)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → U61ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(97) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 7 less nodes.

(98) Obligation:

Q DP problem:
The TRS P consists of the following rules:

MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ANDACTIVE(tt, X) → MARK(X)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U22(x1)) → MARK(x1)
MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U41(x1, x2, x3)) → MARK(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(U42(x1, x2)) → MARK(x1)
MARK(U43(x1)) → MARK(x1)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
MARK(U52(x1, x2)) → MARK(x1)
MARK(U53(x1)) → MARK(x1)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
U61ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
LENGTHACTIVE(cons(N, L)) → U61ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U61ACTIVE(tt, L) → MARK(L)
MARK(U61(x1, x2)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(and(x1, x2)) → MARK(x1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
MARK(length(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(s(x1)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(99) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

MARK(U41(x1, x2, x3)) → U41ACTIVE(mark(x1), x2, x3)
MARK(U41(x1, x2, x3)) → MARK(x1)
MARK(U42(x1, x2)) → U42ACTIVE(mark(x1), x2)
MARK(U42(x1, x2)) → MARK(x1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(ANDACTIVE(x₁, x₂)) = x₂   
POL(ISNATACTIVE(x₁)) = 0   
POL(ISNATILISTACTIVE(x₁)) = 0   
POL(ISNATILISTKINDACTIVE(x₁)) = 0   
POL(ISNATKINDACTIVE(x₁)) = 0   
POL(ISNATLISTACTIVE(x₁)) = 0   
POL(LENGTHACTIVE(x₁)) = x₁   
POL(MARK(x₁)) = x₁   
POL(U21(x₁, x₂)) = x₁   
POL(U21ACTIVE(x₁, x₂)) = 0   
POL(U21Active(x₁, x₂)) = x₁   
POL(U22(x₁)) = x₁   
POL(U22Active(x₁)) = x₁   
POL(U41(x₁, x₂, x₃)) = 1 + x₁   
POL(U41ACTIVE(x₁, x₂, x₃)) = 0   
POL(U41Active(x₁, x₂, x₃)) = 1 + x₁   
POL(U42(x₁, x₂)) = 1 + x₁   
POL(U42ACTIVE(x₁, x₂)) = 0   
POL(U42Active(x₁, x₂)) = 1 + x₁   
POL(U43(x₁)) = x₁   
POL(U43Active(x₁)) = x₁   
POL(U51(x₁, x₂, x₃)) = x₁   
POL(U51ACTIVE(x₁, x₂, x₃)) = 0   
POL(U51Active(x₁, x₂, x₃)) = x₁   
POL(U52(x₁, x₂)) = x₁   
POL(U52ACTIVE(x₁, x₂)) = 0   
POL(U52Active(x₁, x₂)) = x₁   
POL(U53(x₁)) = x₁   
POL(U53Active(x₁)) = x₁   
POL(U61(x₁, x₂)) = x₁ + x₂   
POL(U61ACTIVE(x₁, x₂)) = x₂   
POL(U61Active(x₁, x₂)) = x₁ + x₂   
POL(and(x₁, x₂)) = x₁ + x₂   
POL(andActive(x₁, x₂)) = x₁ + x₂   
POL(cons(x₁, x₂)) = x₁ + x₂   
POL(isNat(x₁)) = 0   
POL(isNatActive(x₁)) = 0   
POL(isNatIList(x₁)) = 1   
POL(isNatIListActive(x₁)) = 1   
POL(isNatIListKind(x₁)) = 0   
POL(isNatIListKindActive(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatKindActive(x₁)) = 0   
POL(isNatList(x₁)) = 0   
POL(isNatListActive(x₁)) = 0   
POL(length(x₁)) = x₁   
POL(lengthActive(x₁)) = x₁   
POL(mark(x₁)) = x₁   
POL(nil) = 0   
POL(s(x₁)) = x₁   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   

The following usable rules [FROCOS05] were oriented:

mark(zeros) → zerosActive
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
zerosActive → zeros
mark(U22(x1)) → U22Active(mark(x1))
U21Active(x1, x2) → U21(x1, x2)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U22Active(x1) → U22(x1)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
mark(isNatKind(x1)) → isNatKindActive(x1)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(length(x1)) → lengthActive(mark(x1))
isNatListActive(x1) → isNatList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(tt) → tt
mark(0) → 0
mark(cons(x1, x2)) → cons(mark(x1), x2)
lengthActive(x1) → length(x1)
U21Active(tt, V1) → U22Active(isNatActive(V1))
zerosActive → cons(0, zeros)
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatKindActive(0) → tt
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)

(100) Obligation:

Q DP problem:
The TRS P consists of the following rules:

MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ANDACTIVE(tt, X) → MARK(X)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U22(x1)) → MARK(x1)
U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
U41ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATILISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U43(x1)) → MARK(x1)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
MARK(U52(x1, x2)) → MARK(x1)
MARK(U53(x1)) → MARK(x1)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
U61ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
LENGTHACTIVE(cons(N, L)) → U61ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U61ACTIVE(tt, L) → MARK(L)
MARK(U61(x1, x2)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(and(x1, x2)) → MARK(x1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
MARK(length(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(s(x1)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(101) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs with 3 less nodes.

(102) Complex Obligation (AND)

(103) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ANDACTIVE(tt, X) → MARK(X)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U22(x1)) → MARK(x1)
MARK(U43(x1)) → MARK(x1)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
MARK(U52(x1, x2)) → MARK(x1)
MARK(U53(x1)) → MARK(x1)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
U61ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
LENGTHACTIVE(cons(N, L)) → U61ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U61ACTIVE(tt, L) → MARK(L)
MARK(U61(x1, x2)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(and(x1, x2)) → MARK(x1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
MARK(length(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(s(x1)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(104) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
MARK(U61(x1, x2)) → MARK(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(length(x1)) → MARK(x1)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(ANDACTIVE(x₁, x₂)) = x₂   
POL(ISNATACTIVE(x₁)) = 0   
POL(ISNATILISTKINDACTIVE(x₁)) = 0   
POL(ISNATKINDACTIVE(x₁)) = 0   
POL(ISNATLISTACTIVE(x₁)) = 0   
POL(LENGTHACTIVE(x₁)) = x₁   
POL(MARK(x₁)) = x₁   
POL(U21(x₁, x₂)) = x₁   
POL(U21ACTIVE(x₁, x₂)) = 0   
POL(U21Active(x₁, x₂)) = x₁   
POL(U22(x₁)) = x₁   
POL(U22Active(x₁)) = x₁   
POL(U41(x₁, x₂, x₃)) = 0   
POL(U41Active(x₁, x₂, x₃)) = 0   
POL(U42(x₁, x₂)) = x₁   
POL(U42Active(x₁, x₂)) = x₁   
POL(U43(x₁)) = x₁   
POL(U43Active(x₁)) = x₁   
POL(U51(x₁, x₂, x₃)) = x₁   
POL(U51ACTIVE(x₁, x₂, x₃)) = 0   
POL(U51Active(x₁, x₂, x₃)) = x₁   
POL(U52(x₁, x₂)) = x₁   
POL(U52ACTIVE(x₁, x₂)) = 0   
POL(U52Active(x₁, x₂)) = x₁   
POL(U53(x₁)) = x₁   
POL(U53Active(x₁)) = x₁   
POL(U61(x₁, x₂)) = 1 + x₁ + x₂   
POL(U61ACTIVE(x₁, x₂)) = x₂   
POL(U61Active(x₁, x₂)) = 1 + x₁ + x₂   
POL(and(x₁, x₂)) = x₁ + x₂   
POL(andActive(x₁, x₂)) = x₁ + x₂   
POL(cons(x₁, x₂)) = x₁ + x₂   
POL(isNat(x₁)) = 0   
POL(isNatActive(x₁)) = 0   
POL(isNatIList(x₁)) = 0   
POL(isNatIListActive(x₁)) = 0   
POL(isNatIListKind(x₁)) = 0   
POL(isNatIListKindActive(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatKindActive(x₁)) = 0   
POL(isNatList(x₁)) = 0   
POL(isNatListActive(x₁)) = 0   
POL(length(x₁)) = 1 + x₁   
POL(lengthActive(x₁)) = 1 + x₁   
POL(mark(x₁)) = x₁   
POL(nil) = 0   
POL(s(x₁)) = x₁   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   

The following usable rules [FROCOS05] were oriented:

mark(zeros) → zerosActive
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
zerosActive → zeros
mark(U22(x1)) → U22Active(mark(x1))
U21Active(x1, x2) → U21(x1, x2)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U22Active(x1) → U22(x1)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
mark(isNatKind(x1)) → isNatKindActive(x1)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(length(x1)) → lengthActive(mark(x1))
isNatListActive(x1) → isNatList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(tt) → tt
mark(0) → 0
mark(cons(x1, x2)) → cons(mark(x1), x2)
lengthActive(x1) → length(x1)
U21Active(tt, V1) → U22Active(isNatActive(V1))
zerosActive → cons(0, zeros)
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatKindActive(0) → tt
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)

(105) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ANDACTIVE(tt, X) → MARK(X)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U22(x1)) → MARK(x1)
MARK(U43(x1)) → MARK(x1)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
MARK(U52(x1, x2)) → MARK(x1)
MARK(U53(x1)) → MARK(x1)
U61ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
LENGTHACTIVE(cons(N, L)) → U61ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
U61ACTIVE(tt, L) → MARK(L)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(and(x1, x2)) → MARK(x1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N)))
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNatIListKind(L))
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
MARK(cons(x1, x2)) → MARK(x1)
MARK(s(x1)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(106) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs with 4 less nodes.

(107) Complex Obligation (AND)

(108) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ANDACTIVE(tt, X) → MARK(X)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U22(x1)) → MARK(x1)
MARK(U43(x1)) → MARK(x1)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
MARK(U52(x1, x2)) → MARK(x1)
MARK(U53(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(and(x1, x2)) → MARK(x1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(s(x1)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(109) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U22(x1)) → MARK(x1)
MARK(U43(x1)) → MARK(x1)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U52(x1, x2)) → U52ACTIVE(mark(x1), x2)
MARK(U52(x1, x2)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(and(x1, x2)) → MARK(x1)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(s(x1)) → MARK(x1)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(ANDACTIVE(x₁, x₂)) = x₂   
POL(ISNATACTIVE(x₁)) = 0   
POL(ISNATILISTKINDACTIVE(x₁)) = 0   
POL(ISNATKINDACTIVE(x₁)) = 0   
POL(ISNATLISTACTIVE(x₁)) = 0   
POL(MARK(x₁)) = x₁   
POL(U21(x₁, x₂)) = 1 + x₁ + x₂   
POL(U21ACTIVE(x₁, x₂)) = 0   
POL(U21Active(x₁, x₂)) = 0   
POL(U22(x₁)) = 1 + x₁   
POL(U22Active(x₁)) = 0   
POL(U41(x₁, x₂, x₃)) = 0   
POL(U41Active(x₁, x₂, x₃)) = 0   
POL(U42(x₁, x₂)) = 0   
POL(U42Active(x₁, x₂)) = 0   
POL(U43(x₁)) = 1 + x₁   
POL(U43Active(x₁)) = 0   
POL(U51(x₁, x₂, x₃)) = 1 + x₁ + x₂ + x₃   
POL(U51ACTIVE(x₁, x₂, x₃)) = 0   
POL(U51Active(x₁, x₂, x₃)) = 0   
POL(U52(x₁, x₂)) = 1 + x₁   
POL(U52ACTIVE(x₁, x₂)) = 0   
POL(U52Active(x₁, x₂)) = 0   
POL(U53(x₁)) = x₁   
POL(U53Active(x₁)) = 0   
POL(U61(x₁, x₂)) = 0   
POL(U61Active(x₁, x₂)) = 0   
POL(and(x₁, x₂)) = 1 + x₁ + x₂   
POL(andActive(x₁, x₂)) = 0   
POL(cons(x₁, x₂)) = 1 + x₁   
POL(isNat(x₁)) = 0   
POL(isNatActive(x₁)) = 0   
POL(isNatIList(x₁)) = 0   
POL(isNatIListActive(x₁)) = 0   
POL(isNatIListKind(x₁)) = 0   
POL(isNatIListKindActive(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatKindActive(x₁)) = 0   
POL(isNatList(x₁)) = 1 + x₁   
POL(isNatListActive(x₁)) = 0   
POL(length(x₁)) = 0   
POL(lengthActive(x₁)) = 0   
POL(mark(x₁)) = 0   
POL(nil) = 0   
POL(s(x₁)) = 1 + x₁   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   

The following usable rules [FROCOS05] were oriented: none

(110) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ANDACTIVE(tt, X) → MARK(X)
U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
U51ACTIVE(tt, V1, V2) → ISNATACTIVE(V1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(U53(x1)) → MARK(x1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(111) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 2 SCCs with 3 less nodes.

(112) Complex Obligation (AND)

(113) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ANDACTIVE(tt, X) → MARK(X)
MARK(U53(x1)) → MARK(x1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(114) Instantiation (EQUIVALENT transformation)

By instantiating [LPAR04] the rule ANDACTIVE(tt, X) → MARK(X) we obtained the following new rules [LPAR04]:

ANDACTIVE(tt, isNatIListKind(y_2)) → MARK(isNatIListKind(y_2))

(115) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
ISNATACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
MARK(U53(x1)) → MARK(x1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)
MARK(isNatKind(x1)) → ISNATKINDACTIVE(x1)
ANDACTIVE(tt, isNatIListKind(y_2)) → MARK(isNatIListKind(y_2))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(116) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 3 SCCs with 3 less nodes.

(117) Complex Obligation (AND)

(118) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ANDACTIVE(tt, isNatIListKind(y_2)) → MARK(isNatIListKind(y_2))
MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(119) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

MARK(isNatIListKind(x1)) → ISNATILISTKINDACTIVE(x1)
ISNATILISTKINDACTIVE(cons(V1, V2)) → ISNATKINDACTIVE(V1)
ISNATKINDACTIVE(length(V1)) → ISNATILISTKINDACTIVE(V1)
ISNATKINDACTIVE(s(V1)) → ISNATKINDACTIVE(V1)

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(ANDACTIVE(x₁, x₂)) = 1 + x₂   
POL(ISNATILISTKINDACTIVE(x₁)) = 1 + x₁   
POL(ISNATKINDACTIVE(x₁)) = 1 + x₁   
POL(MARK(x₁)) = 1 + x₁   
POL(U21(x₁, x₂)) = 0   
POL(U21Active(x₁, x₂)) = 0   
POL(U22(x₁)) = 0   
POL(U22Active(x₁)) = 0   
POL(U41(x₁, x₂, x₃)) = 0   
POL(U41Active(x₁, x₂, x₃)) = 0   
POL(U42(x₁, x₂)) = 0   
POL(U42Active(x₁, x₂)) = 0   
POL(U43(x₁)) = 0   
POL(U43Active(x₁)) = 0   
POL(U51(x₁, x₂, x₃)) = 0   
POL(U51Active(x₁, x₂, x₃)) = 0   
POL(U52(x₁, x₂)) = 0   
POL(U52Active(x₁, x₂)) = 0   
POL(U53(x₁)) = 0   
POL(U53Active(x₁)) = 0   
POL(U61(x₁, x₂)) = 0   
POL(U61Active(x₁, x₂)) = 0   
POL(and(x₁, x₂)) = 0   
POL(andActive(x₁, x₂)) = 0   
POL(cons(x₁, x₂)) = 1 + x₁ + x₂   
POL(isNat(x₁)) = 0   
POL(isNatActive(x₁)) = 0   
POL(isNatIList(x₁)) = 0   
POL(isNatIListActive(x₁)) = 0   
POL(isNatIListKind(x₁)) = 1 + x₁   
POL(isNatIListKindActive(x₁)) = 0   
POL(isNatKind(x₁)) = 0   
POL(isNatKindActive(x₁)) = 0   
POL(isNatList(x₁)) = 0   
POL(isNatListActive(x₁)) = 0   
POL(length(x₁)) = 1 + x₁   
POL(lengthActive(x₁)) = 0   
POL(mark(x₁)) = 0   
POL(nil) = 0   
POL(s(x₁)) = 1 + x₁   
POL(tt) = 0   
POL(zeros) = 0   
POL(zerosActive) = 0   

The following usable rules [FROCOS05] were oriented: none

(120) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ISNATILISTKINDACTIVE(cons(V1, V2)) → ANDACTIVE(isNatKindActive(V1), isNatIListKind(V2))
ANDACTIVE(tt, isNatIListKind(y_2)) → MARK(isNatIListKind(y_2))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(121) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 2 less nodes.

(122) TRUE

(123) Obligation:

Q DP problem:
The TRS P consists of the following rules:

ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
U21ACTIVE(tt, V1) → ISNATACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(124) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

• U21ACTIVE(tt, V1) → ISNATACTIVE(V1)
  The graph contains the following edges 2 >= 1

• ISNATACTIVE(s(V1)) → U21ACTIVE(isNatKindActive(V1), V1)
  The graph contains the following edges 1 > 2

(125) TRUE

(126) Obligation:

Q DP problem:
The TRS P consists of the following rules:

MARK(U53(x1)) → MARK(x1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(127) UsableRulesProof (EQUIVALENT transformation)

We can use the usable rules and reduction pair processor [LPAR04] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its arguments. Then, we can delete all non-usable rules [FROCOS05] from R.

(128) Obligation:

Q DP problem:
The TRS P consists of the following rules:

MARK(U53(x1)) → MARK(x1)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(129) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

• MARK(U53(x1)) → MARK(x1)
  The graph contains the following edges 1 > 1

(130) TRUE

(131) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(132) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

• U52ACTIVE(tt, V2) → ISNATLISTACTIVE(V2)
  The graph contains the following edges 2 >= 1

• ISNATLISTACTIVE(cons(V1, V2)) → U51ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
  The graph contains the following edges 1 > 2, 1 > 3

• U51ACTIVE(tt, V1, V2) → U52ACTIVE(isNatActive(V1), V2)
  The graph contains the following edges 3 >= 2

(133) TRUE

(134) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U61ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
LENGTHACTIVE(cons(N, L)) → U61ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(135) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].

The following pairs can be oriented strictly and are deleted.

U61ACTIVE(tt, L) → LENGTHACTIVE(mark(L))

The remaining pairs can at least be oriented weakly.
Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(LENGTHACTIVE(x₁)) = 0   
POL(U21(x₁, x₂)) = x₁   
POL(U21Active(x₁, x₂)) = x₁   
POL(U22(x₁)) = 1   
POL(U22Active(x₁)) = 1   
POL(U41(x₁, x₂, x₃)) = 0   
POL(U41Active(x₁, x₂, x₃)) = 0   
POL(U42(x₁, x₂)) = 0   
POL(U42Active(x₁, x₂)) = 0   
POL(U43(x₁)) = 0   
POL(U43Active(x₁)) = x₁   
POL(U51(x₁, x₂, x₃)) = 0   
POL(U51Active(x₁, x₂, x₃)) = 0   
POL(U52(x₁, x₂)) = 0   
POL(U52Active(x₁, x₂)) = 0   
POL(U53(x₁)) = 0   
POL(U53Active(x₁)) = x₁   
POL(U61(x₁, x₂)) = 0   
POL(U61ACTIVE(x₁, x₂)) = x₁   
POL(U61Active(x₁, x₂)) = 0   
POL(and(x₁, x₂)) = 0   
POL(andActive(x₁, x₂)) = x₁   
POL(cons(x₁, x₂)) = 0   
POL(isNat(x₁)) = 0   
POL(isNatActive(x₁)) = 1   
POL(isNatIList(x₁)) = 0   
POL(isNatIListActive(x₁)) = 0   
POL(isNatIListKind(x₁)) = 0   
POL(isNatIListKindActive(x₁)) = 1   
POL(isNatKind(x₁)) = 0   
POL(isNatKindActive(x₁)) = 1   
POL(isNatList(x₁)) = 0   
POL(isNatListActive(x₁)) = 0   
POL(length(x₁)) = 0   
POL(lengthActive(x₁)) = x₁   
POL(mark(x₁)) = 1   
POL(nil) = 0   
POL(s(x₁)) = 0   
POL(tt) = 1   
POL(zeros) = 0   
POL(zerosActive) = 0   

The following usable rules [FROCOS05] were oriented:

mark(zeros) → zerosActive
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
zerosActive → zeros
mark(U22(x1)) → U22Active(mark(x1))
U21Active(x1, x2) → U21(x1, x2)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U22Active(x1) → U22(x1)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
mark(isNatKind(x1)) → isNatKindActive(x1)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(length(x1)) → lengthActive(mark(x1))
isNatListActive(x1) → isNatList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(tt) → tt
mark(0) → 0
mark(cons(x1, x2)) → cons(mark(x1), x2)
lengthActive(x1) → length(x1)
U21Active(tt, V1) → U22Active(isNatActive(V1))
zerosActive → cons(0, zeros)
mark(nil) → nil
mark(s(x1)) → s(mark(x1))
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatKindActive(0) → tt
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)

(136) Obligation:

Q DP problem:
The TRS P consists of the following rules:

LENGTHACTIVE(cons(N, L)) → U61ACTIVE(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(137) DependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(138) TRUE

(139) Obligation:

Q DP problem:
The TRS P consists of the following rules:

U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U22(x1)) → U22Active(mark(x1))
U22Active(x1) → U22(x1)
mark(U41(x1, x2, x3)) → U41Active(mark(x1), x2, x3)
U41Active(x1, x2, x3) → U41(x1, x2, x3)
mark(U42(x1, x2)) → U42Active(mark(x1), x2)
U42Active(x1, x2) → U42(x1, x2)
mark(U43(x1)) → U43Active(mark(x1))
U43Active(x1) → U43(x1)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U52(x1, x2)) → U52Active(mark(x1), x2)
U52Active(x1, x2) → U52(x1, x2)
mark(U53(x1)) → U53Active(mark(x1))
U53Active(x1) → U53(x1)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatIListKind(x1)) → isNatIListKindActive(x1)
isNatIListKindActive(x1) → isNatIListKind(x1)
mark(isNatKind(x1)) → isNatKindActive(x1)
isNatKindActive(x1) → isNatKind(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U21Active(tt, V1) → U22Active(isNatActive(V1))
U22Active(tt) → tt
U41Active(tt, V1, V2) → U42Active(isNatActive(V1), V2)
U42Active(tt, V2) → U43Active(isNatIListActive(V2))
U43Active(tt) → tt
U51Active(tt, V1, V2) → U52Active(isNatActive(V1), V2)
U52Active(tt, V2) → U53Active(isNatListActive(V2))
U53Active(tt) → tt
U61Active(tt, L) → s(lengthActive(mark(L)))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(s(V1)) → U21Active(isNatKindActive(V1), V1)
isNatIListActive(cons(V1, V2)) → U41Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
isNatIListKindActive(nil) → tt
isNatIListKindActive(zeros) → tt
isNatIListKindActive(cons(V1, V2)) → andActive(isNatKindActive(V1), isNatIListKind(V2))
isNatKindActive(0) → tt
isNatKindActive(length(V1)) → isNatIListKindActive(V1)
isNatKindActive(s(V1)) → isNatKindActive(V1)
isNatListActive(cons(V1, V2)) → U51Active(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
lengthActive(cons(N, L)) → U61Active(andActive(andActive(isNatListActive(L), isNatIListKind(L)), and(isNat(N), isNatKind(N))), L)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

(140) QDPSizeChangeProof (EQUIVALENT transformation)

By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:

• U42ACTIVE(tt, V2) → ISNATILISTACTIVE(V2)
  The graph contains the following edges 2 >= 1

• ISNATILISTACTIVE(cons(V1, V2)) → U41ACTIVE(andActive(isNatKindActive(V1), isNatIListKind(V2)), V1, V2)
  The graph contains the following edges 1 > 2, 1 > 3

• U41ACTIVE(tt, V1, V2) → U42ACTIVE(isNatActive(V1), V2)
  The graph contains the following edges 3 >= 2

(141) TRUE