(0) Obligation:

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

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

Q is empty.

(1) DependencyPairsProof (EQUIVALENT transformation)

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

(2) Obligation:

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

ACTIVE(isNatIList(IL)) → ISNATLIST(IL)
ACTIVE(isNat(s(N))) → ISNAT(N)
ACTIVE(isNat(length(L))) → ISNATLIST(L)
ACTIVE(isNatIList(cons(N, IL))) → AND(isNat(N), isNatIList(IL))
ACTIVE(isNatIList(cons(N, IL))) → ISNAT(N)
ACTIVE(isNatIList(cons(N, IL))) → ISNATILIST(IL)
ACTIVE(isNatList(cons(N, L))) → AND(isNat(N), isNatList(L))
ACTIVE(isNatList(cons(N, L))) → ISNAT(N)
ACTIVE(isNatList(cons(N, L))) → ISNATLIST(L)
ACTIVE(isNatList(take(N, IL))) → AND(isNat(N), isNatIList(IL))
ACTIVE(isNatList(take(N, IL))) → ISNAT(N)
ACTIVE(isNatList(take(N, IL))) → ISNATILIST(IL)
ACTIVE(zeros) → CONS(0, zeros)
ACTIVE(take(0, IL)) → UTAKE1(isNatIList(IL))
ACTIVE(take(0, IL)) → ISNATILIST(IL)
ACTIVE(take(s(M), cons(N, IL))) → UTAKE2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL)
ACTIVE(take(s(M), cons(N, IL))) → AND(isNat(M), and(isNat(N), isNatIList(IL)))
ACTIVE(take(s(M), cons(N, IL))) → ISNAT(M)
ACTIVE(take(s(M), cons(N, IL))) → AND(isNat(N), isNatIList(IL))
ACTIVE(take(s(M), cons(N, IL))) → ISNAT(N)
ACTIVE(take(s(M), cons(N, IL))) → ISNATILIST(IL)
ACTIVE(uTake2(tt, M, N, IL)) → CONS(N, take(M, IL))
ACTIVE(uTake2(tt, M, N, IL)) → TAKE(M, IL)
ACTIVE(length(cons(N, L))) → ULENGTH(and(isNat(N), isNatList(L)), L)
ACTIVE(length(cons(N, L))) → AND(isNat(N), isNatList(L))
ACTIVE(length(cons(N, L))) → ISNAT(N)
ACTIVE(length(cons(N, L))) → ISNATLIST(L)
ACTIVE(uLength(tt, L)) → S(length(L))
ACTIVE(uLength(tt, L)) → LENGTH(L)
ACTIVE(and(X1, X2)) → AND(active(X1), X2)
ACTIVE(and(X1, X2)) → ACTIVE(X1)
ACTIVE(and(X1, X2)) → AND(X1, active(X2))
ACTIVE(and(X1, X2)) → ACTIVE(X2)
ACTIVE(s(X)) → S(active(X))
ACTIVE(s(X)) → ACTIVE(X)
ACTIVE(length(X)) → LENGTH(active(X))
ACTIVE(length(X)) → ACTIVE(X)
ACTIVE(cons(X1, X2)) → CONS(active(X1), X2)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(take(X1, X2)) → TAKE(active(X1), X2)
ACTIVE(take(X1, X2)) → ACTIVE(X1)
ACTIVE(take(X1, X2)) → TAKE(X1, active(X2))
ACTIVE(take(X1, X2)) → ACTIVE(X2)
ACTIVE(uTake1(X)) → UTAKE1(active(X))
ACTIVE(uTake1(X)) → ACTIVE(X)
ACTIVE(uTake2(X1, X2, X3, X4)) → UTAKE2(active(X1), X2, X3, X4)
ACTIVE(uTake2(X1, X2, X3, X4)) → ACTIVE(X1)
ACTIVE(uLength(X1, X2)) → ULENGTH(active(X1), X2)
ACTIVE(uLength(X1, X2)) → ACTIVE(X1)
AND(mark(X1), X2) → AND(X1, X2)
AND(X1, mark(X2)) → AND(X1, X2)
S(mark(X)) → S(X)
LENGTH(mark(X)) → LENGTH(X)
CONS(mark(X1), X2) → CONS(X1, X2)
TAKE(mark(X1), X2) → TAKE(X1, X2)
TAKE(X1, mark(X2)) → TAKE(X1, X2)
UTAKE1(mark(X)) → UTAKE1(X)
UTAKE2(mark(X1), X2, X3, X4) → UTAKE2(X1, X2, X3, X4)
ULENGTH(mark(X1), X2) → ULENGTH(X1, X2)
PROPER(and(X1, X2)) → AND(proper(X1), proper(X2))
PROPER(and(X1, X2)) → PROPER(X1)
PROPER(and(X1, X2)) → PROPER(X2)
PROPER(isNatIList(X)) → ISNATILIST(proper(X))
PROPER(isNatIList(X)) → PROPER(X)
PROPER(isNatList(X)) → ISNATLIST(proper(X))
PROPER(isNatList(X)) → PROPER(X)
PROPER(isNat(X)) → ISNAT(proper(X))
PROPER(isNat(X)) → PROPER(X)
PROPER(s(X)) → S(proper(X))
PROPER(s(X)) → PROPER(X)
PROPER(length(X)) → LENGTH(proper(X))
PROPER(length(X)) → PROPER(X)
PROPER(cons(X1, X2)) → CONS(proper(X1), proper(X2))
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(take(X1, X2)) → TAKE(proper(X1), proper(X2))
PROPER(take(X1, X2)) → PROPER(X1)
PROPER(take(X1, X2)) → PROPER(X2)
PROPER(uTake1(X)) → UTAKE1(proper(X))
PROPER(uTake1(X)) → PROPER(X)
PROPER(uTake2(X1, X2, X3, X4)) → UTAKE2(proper(X1), proper(X2), proper(X3), proper(X4))
PROPER(uTake2(X1, X2, X3, X4)) → PROPER(X1)
PROPER(uTake2(X1, X2, X3, X4)) → PROPER(X2)
PROPER(uTake2(X1, X2, X3, X4)) → PROPER(X3)
PROPER(uTake2(X1, X2, X3, X4)) → PROPER(X4)
PROPER(uLength(X1, X2)) → ULENGTH(proper(X1), proper(X2))
PROPER(uLength(X1, X2)) → PROPER(X1)
PROPER(uLength(X1, X2)) → PROPER(X2)
AND(ok(X1), ok(X2)) → AND(X1, X2)
ISNATILIST(ok(X)) → ISNATILIST(X)
ISNATLIST(ok(X)) → ISNATLIST(X)
ISNAT(ok(X)) → ISNAT(X)
S(ok(X)) → S(X)
LENGTH(ok(X)) → LENGTH(X)
CONS(ok(X1), ok(X2)) → CONS(X1, X2)
TAKE(ok(X1), ok(X2)) → TAKE(X1, X2)
UTAKE1(ok(X)) → UTAKE1(X)
UTAKE2(ok(X1), ok(X2), ok(X3), ok(X4)) → UTAKE2(X1, X2, X3, X4)
ULENGTH(ok(X1), ok(X2)) → ULENGTH(X1, X2)
TOP(mark(X)) → TOP(proper(X))
TOP(mark(X)) → PROPER(X)
TOP(ok(X)) → TOP(active(X))
TOP(ok(X)) → ACTIVE(X)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(3) DependencyGraphProof (EQUIVALENT transformation)

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

(4) Complex Obligation (AND)

(5) Obligation:

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

ISNAT(ok(X)) → ISNAT(X)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(6) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ISNAT(ok(X)) → ISNAT(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ISNAT(x1)  =  ISNAT(x1)
ok(x1)  =  ok(x1)
active(x1)  =  x1
and(x1, x2)  =  x2
tt  =  tt
mark(x1)  =  x1
isNatIList(x1)  =  x1
isNatList(x1)  =  x1
isNat(x1)  =  isNat(x1)
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  x2
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  x4
uLength(x1, x2)  =  x2
proper(x1)  =  proper(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
[proper1, top] > [ok1, isNat1] > [tt, nil]
[proper1, top] > 0 > [tt, nil]
[proper1, top] > zeros > [tt, nil]

Status:
ISNAT1: [1]
ok1: [1]
tt: []
isNat1: [1]
0: []
zeros: []
nil: []
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(7) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(8) PisEmptyProof (EQUIVALENT transformation)

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

(9) TRUE

(10) Obligation:

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

ISNATLIST(ok(X)) → ISNATLIST(X)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(11) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ISNATLIST(ok(X)) → ISNATLIST(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ISNATLIST(x1)  =  ISNATLIST(x1)
ok(x1)  =  ok(x1)
active(x1)  =  x1
and(x1, x2)  =  x2
tt  =  tt
mark(x1)  =  x1
isNatIList(x1)  =  x1
isNatList(x1)  =  x1
isNat(x1)  =  isNat(x1)
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  x2
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  x4
uLength(x1, x2)  =  x2
proper(x1)  =  proper(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
[proper1, top] > [ok1, isNat1] > [tt, nil]
[proper1, top] > 0 > [tt, nil]
[proper1, top] > zeros > [tt, nil]

Status:
ISNATLIST1: [1]
ok1: [1]
tt: []
isNat1: [1]
0: []
zeros: []
nil: []
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(12) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(13) PisEmptyProof (EQUIVALENT transformation)

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

(14) TRUE

(15) Obligation:

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

ISNATILIST(ok(X)) → ISNATILIST(X)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(16) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ISNATILIST(ok(X)) → ISNATILIST(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ISNATILIST(x1)  =  ISNATILIST(x1)
ok(x1)  =  ok(x1)
active(x1)  =  x1
and(x1, x2)  =  x2
tt  =  tt
mark(x1)  =  x1
isNatIList(x1)  =  x1
isNatList(x1)  =  x1
isNat(x1)  =  isNat(x1)
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  x2
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  x4
uLength(x1, x2)  =  x2
proper(x1)  =  proper(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
[proper1, top] > [ok1, isNat1] > [tt, nil]
[proper1, top] > 0 > [tt, nil]
[proper1, top] > zeros > [tt, nil]

Status:
ISNATILIST1: [1]
ok1: [1]
tt: []
isNat1: [1]
0: []
zeros: []
nil: []
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(17) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(18) PisEmptyProof (EQUIVALENT transformation)

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

(19) TRUE

(20) Obligation:

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

ULENGTH(ok(X1), ok(X2)) → ULENGTH(X1, X2)
ULENGTH(mark(X1), X2) → ULENGTH(X1, X2)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(21) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ULENGTH(ok(X1), ok(X2)) → ULENGTH(X1, X2)
ULENGTH(mark(X1), X2) → ULENGTH(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ULENGTH(x1, x2)  =  ULENGTH(x1)
ok(x1)  =  ok(x1)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x1, x2)
tt  =  tt
isNatIList(x1)  =  isNatIList(x1)
isNatList(x1)  =  isNatList(x1)
isNat(x1)  =  isNat(x1)
0  =  0
s(x1)  =  x1
length(x1)  =  length(x1)
zeros  =  zeros
cons(x1, x2)  =  cons(x1, x2)
nil  =  nil
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  uTake1(x1)
uTake2(x1, x2, x3, x4)  =  uTake2(x1, x2, x3, x4)
uLength(x1, x2)  =  uLength(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
proper1 > [active1, length1, uTake24, top] > and2 > [ULENGTH1, ok1, mark1, isNatList1, uTake11] > nil
proper1 > [active1, length1, uTake24, top] > tt > [isNatIList1, cons2, take2, uLength2] > [ULENGTH1, ok1, mark1, isNatList1, uTake11] > nil
proper1 > [active1, length1, uTake24, top] > isNat1 > [ULENGTH1, ok1, mark1, isNatList1, uTake11] > nil
proper1 > [0, zeros] > tt > [isNatIList1, cons2, take2, uLength2] > [ULENGTH1, ok1, mark1, isNatList1, uTake11] > nil

Status:
ULENGTH1: [1]
ok1: [1]
mark1: [1]
active1: [1]
and2: [2,1]
tt: []
isNatIList1: [1]
isNatList1: [1]
isNat1: [1]
0: []
length1: [1]
zeros: []
cons2: [2,1]
nil: []
take2: [2,1]
uTake11: [1]
uTake24: [4,1,2,3]
uLength2: [2,1]
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(22) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(23) PisEmptyProof (EQUIVALENT transformation)

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

(24) TRUE

(25) Obligation:

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

UTAKE2(ok(X1), ok(X2), ok(X3), ok(X4)) → UTAKE2(X1, X2, X3, X4)
UTAKE2(mark(X1), X2, X3, X4) → UTAKE2(X1, X2, X3, X4)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(26) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


UTAKE2(ok(X1), ok(X2), ok(X3), ok(X4)) → UTAKE2(X1, X2, X3, X4)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
UTAKE2(x1, x2, x3, x4)  =  UTAKE2(x3, x4)
ok(x1)  =  ok(x1)
mark(x1)  =  mark
active(x1)  =  active(x1)
and(x1, x2)  =  x1
tt  =  tt
isNatIList(x1)  =  x1
isNatList(x1)  =  x1
isNat(x1)  =  x1
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  x1
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  x3
uLength(x1, x2)  =  x2
proper(x1)  =  proper
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
UTAKE22 > [ok1, mark, tt, 0, zeros, nil]
active1 > [ok1, mark, tt, 0, zeros, nil]
top > proper > [ok1, mark, tt, 0, zeros, nil]

Status:
UTAKE22: [2,1]
ok1: [1]
mark: []
active1: [1]
tt: []
0: []
zeros: []
nil: []
proper: []
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(27) Obligation:

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

UTAKE2(mark(X1), X2, X3, X4) → UTAKE2(X1, X2, X3, X4)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(28) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


UTAKE2(mark(X1), X2, X3, X4) → UTAKE2(X1, X2, X3, X4)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
UTAKE2(x1, x2, x3, x4)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x1, x2)
tt  =  tt
isNatIList(x1)  =  x1
isNatList(x1)  =  isNatList(x1)
isNat(x1)  =  x1
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  cons(x1, x2)
nil  =  nil
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  uTake2(x1, x2, x3, x4)
uLength(x1, x2)  =  uLength(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  x1
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
proper1 > [active1, uTake24] > zeros > 0 > [mark1, tt]
proper1 > [active1, uTake24] > zeros > [cons2, uLength2] > [and2, isNatList1] > [mark1, tt]
proper1 > [active1, uTake24] > nil > [mark1, tt]
proper1 > [active1, uTake24] > take2 > [and2, isNatList1] > [mark1, tt]
top > [mark1, tt]

Status:
mark1: [1]
active1: [1]
and2: [2,1]
tt: []
isNatList1: [1]
0: []
zeros: []
cons2: [2,1]
nil: []
take2: [1,2]
uTake24: [1,3,4,2]
uLength2: [2,1]
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(29) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(30) PisEmptyProof (EQUIVALENT transformation)

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

(31) TRUE

(32) Obligation:

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

UTAKE1(ok(X)) → UTAKE1(X)
UTAKE1(mark(X)) → UTAKE1(X)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(33) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


UTAKE1(mark(X)) → UTAKE1(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
UTAKE1(x1)  =  x1
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x1, x2)
tt  =  tt
isNatIList(x1)  =  isNatIList
isNatList(x1)  =  isNatList
isNat(x1)  =  isNat
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  cons(x1, x2)
nil  =  nil
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  uTake2(x1, x2, x3, x4)
uLength(x1, x2)  =  uLength(x1, x2)
proper(x1)  =  x1
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
active1 > zeros > [and2, cons2] > mark1 > [tt, isNatIList, isNatList, isNat, 0]
active1 > nil > mark1 > [tt, isNatIList, isNatList, isNat, 0]
active1 > take2 > uTake24 > [and2, cons2] > mark1 > [tt, isNatIList, isNatList, isNat, 0]
active1 > uLength2 > mark1 > [tt, isNatIList, isNatList, isNat, 0]
top > [tt, isNatIList, isNatList, isNat, 0]

Status:
mark1: [1]
active1: [1]
and2: [1,2]
tt: []
isNatIList: []
isNatList: []
isNat: []
0: []
zeros: []
cons2: [1,2]
nil: []
take2: [2,1]
uTake24: [3,1,4,2]
uLength2: [2,1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(34) Obligation:

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

UTAKE1(ok(X)) → UTAKE1(X)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(35) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


UTAKE1(ok(X)) → UTAKE1(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
UTAKE1(x1)  =  UTAKE1(x1)
ok(x1)  =  ok(x1)
active(x1)  =  x1
and(x1, x2)  =  x2
tt  =  tt
mark(x1)  =  x1
isNatIList(x1)  =  x1
isNatList(x1)  =  x1
isNat(x1)  =  isNat(x1)
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  x2
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  x4
uLength(x1, x2)  =  x2
proper(x1)  =  proper(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
[proper1, top] > [ok1, isNat1] > [tt, nil]
[proper1, top] > 0 > [tt, nil]
[proper1, top] > zeros > [tt, nil]

Status:
UTAKE11: [1]
ok1: [1]
tt: []
isNat1: [1]
0: []
zeros: []
nil: []
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(36) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(37) PisEmptyProof (EQUIVALENT transformation)

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

(38) TRUE

(39) Obligation:

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

TAKE(X1, mark(X2)) → TAKE(X1, X2)
TAKE(mark(X1), X2) → TAKE(X1, X2)
TAKE(ok(X1), ok(X2)) → TAKE(X1, X2)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(40) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


TAKE(ok(X1), ok(X2)) → TAKE(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
TAKE(x1, x2)  =  x2
mark(x1)  =  x1
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x2)
tt  =  tt
isNatIList(x1)  =  isNatIList(x1)
isNatList(x1)  =  isNatList(x1)
isNat(x1)  =  isNat(x1)
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  x2
uTake1(x1)  =  uTake1(x1)
uTake2(x1, x2, x3, x4)  =  uTake2(x4)
uLength(x1, x2)  =  x2
proper(x1)  =  proper(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
[isNat1, proper1] > [active1, nil] > and1 > ok1 > top
[isNat1, proper1] > [active1, nil] > isNatList1 > isNatIList1 > ok1 > top
[isNat1, proper1] > [active1, nil] > isNatList1 > isNatIList1 > tt > top
[isNat1, proper1] > [active1, nil] > 0 > isNatIList1 > ok1 > top
[isNat1, proper1] > [active1, nil] > 0 > isNatIList1 > tt > top
[isNat1, proper1] > [active1, nil] > 0 > uTake11 > ok1 > top
[isNat1, proper1] > [active1, nil] > zeros > ok1 > top
[isNat1, proper1] > [active1, nil] > zeros > tt > top
[isNat1, proper1] > [active1, nil] > uTake21 > ok1 > top

Status:
ok1: [1]
active1: [1]
and1: [1]
tt: []
isNatIList1: [1]
isNatList1: [1]
isNat1: [1]
0: []
zeros: []
nil: []
uTake11: [1]
uTake21: [1]
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(41) Obligation:

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

TAKE(X1, mark(X2)) → TAKE(X1, X2)
TAKE(mark(X1), X2) → TAKE(X1, X2)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(42) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


TAKE(X1, mark(X2)) → TAKE(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
TAKE(x1, x2)  =  TAKE(x2)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x1, x2)
tt  =  tt
isNatIList(x1)  =  isNatIList
isNatList(x1)  =  isNatList
isNat(x1)  =  isNat
0  =  0
s(x1)  =  s(x1)
length(x1)  =  length(x1)
zeros  =  zeros
cons(x1, x2)  =  cons(x1, x2)
nil  =  nil
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  uTake1(x1)
uTake2(x1, x2, x3, x4)  =  uTake2(x1, x2, x3, x4)
uLength(x1, x2)  =  uLength(x1, x2)
proper(x1)  =  x1
ok(x1)  =  ok
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
TAKE1 > [tt, ok]
[active1, uTake24, uLength2, top] > [0, zeros, cons2] > [and2, length1, nil, take2, uTake11] > [mark1, isNatIList, s1] > isNatList > isNat > [tt, ok]

Status:
TAKE1: [1]
mark1: [1]
active1: [1]
and2: [1,2]
tt: []
isNatIList: []
isNatList: []
isNat: []
0: []
s1: [1]
length1: [1]
zeros: []
cons2: [1,2]
nil: []
take2: [1,2]
uTake11: [1]
uTake24: [3,1,4,2]
uLength2: [1,2]
ok: []
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(43) Obligation:

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

TAKE(mark(X1), X2) → TAKE(X1, X2)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(44) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


TAKE(mark(X1), X2) → TAKE(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
TAKE(x1, x2)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x1, x2)
tt  =  tt
isNatIList(x1)  =  isNatIList
isNatList(x1)  =  isNatList
isNat(x1)  =  isNat
0  =  0
s(x1)  =  s(x1)
length(x1)  =  length(x1)
zeros  =  zeros
cons(x1, x2)  =  cons(x1, x2)
nil  =  nil
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  uTake1(x1)
uTake2(x1, x2, x3, x4)  =  uTake2(x1, x2, x3, x4)
uLength(x1, x2)  =  uLength(x1, x2)
proper(x1)  =  x1
ok(x1)  =  x1
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
zeros > [active1, and2, tt, isNatIList, isNatList, 0, cons2, take2, uTake24, uLength2, top] > [mark1, isNat, s1, length1, nil, uTake11]

Status:
mark1: [1]
active1: [1]
and2: [1,2]
tt: []
isNatIList: []
isNatList: []
isNat: []
0: []
s1: [1]
length1: [1]
zeros: []
cons2: [1,2]
nil: []
take2: [1,2]
uTake11: [1]
uTake24: [2,3,1,4]
uLength2: [2,1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(45) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(46) PisEmptyProof (EQUIVALENT transformation)

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

(47) TRUE

(48) Obligation:

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

CONS(ok(X1), ok(X2)) → CONS(X1, X2)
CONS(mark(X1), X2) → CONS(X1, X2)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(49) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


CONS(ok(X1), ok(X2)) → CONS(X1, X2)
CONS(mark(X1), X2) → CONS(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
CONS(x1, x2)  =  CONS(x1)
ok(x1)  =  ok(x1)
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x1, x2)
tt  =  tt
isNatIList(x1)  =  isNatIList(x1)
isNatList(x1)  =  isNatList(x1)
isNat(x1)  =  isNat(x1)
0  =  0
s(x1)  =  x1
length(x1)  =  length(x1)
zeros  =  zeros
cons(x1, x2)  =  cons(x1, x2)
nil  =  nil
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  uTake1(x1)
uTake2(x1, x2, x3, x4)  =  uTake2(x1, x2, x3, x4)
uLength(x1, x2)  =  uLength(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
proper1 > [active1, length1, uTake24, top] > and2 > [CONS1, ok1, mark1, isNatList1, uTake11] > nil
proper1 > [active1, length1, uTake24, top] > tt > [isNatIList1, cons2, take2, uLength2] > [CONS1, ok1, mark1, isNatList1, uTake11] > nil
proper1 > [active1, length1, uTake24, top] > isNat1 > [CONS1, ok1, mark1, isNatList1, uTake11] > nil
proper1 > [0, zeros] > tt > [isNatIList1, cons2, take2, uLength2] > [CONS1, ok1, mark1, isNatList1, uTake11] > nil

Status:
CONS1: [1]
ok1: [1]
mark1: [1]
active1: [1]
and2: [2,1]
tt: []
isNatIList1: [1]
isNatList1: [1]
isNat1: [1]
0: []
length1: [1]
zeros: []
cons2: [2,1]
nil: []
take2: [2,1]
uTake11: [1]
uTake24: [4,1,2,3]
uLength2: [2,1]
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(50) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(51) PisEmptyProof (EQUIVALENT transformation)

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

(52) TRUE

(53) Obligation:

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

LENGTH(ok(X)) → LENGTH(X)
LENGTH(mark(X)) → LENGTH(X)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(54) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


LENGTH(mark(X)) → LENGTH(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
LENGTH(x1)  =  x1
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x1, x2)
tt  =  tt
isNatIList(x1)  =  isNatIList
isNatList(x1)  =  isNatList
isNat(x1)  =  isNat
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  cons(x1, x2)
nil  =  nil
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  uTake2(x1, x2, x3, x4)
uLength(x1, x2)  =  uLength(x1, x2)
proper(x1)  =  x1
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
active1 > zeros > [and2, cons2] > mark1 > [tt, isNatIList, isNatList, isNat, 0]
active1 > nil > mark1 > [tt, isNatIList, isNatList, isNat, 0]
active1 > take2 > uTake24 > [and2, cons2] > mark1 > [tt, isNatIList, isNatList, isNat, 0]
active1 > uLength2 > mark1 > [tt, isNatIList, isNatList, isNat, 0]
top > [tt, isNatIList, isNatList, isNat, 0]

Status:
mark1: [1]
active1: [1]
and2: [1,2]
tt: []
isNatIList: []
isNatList: []
isNat: []
0: []
zeros: []
cons2: [1,2]
nil: []
take2: [2,1]
uTake24: [3,1,4,2]
uLength2: [2,1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(55) Obligation:

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

LENGTH(ok(X)) → LENGTH(X)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(56) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


LENGTH(ok(X)) → LENGTH(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
LENGTH(x1)  =  LENGTH(x1)
ok(x1)  =  ok(x1)
active(x1)  =  x1
and(x1, x2)  =  x2
tt  =  tt
mark(x1)  =  x1
isNatIList(x1)  =  x1
isNatList(x1)  =  x1
isNat(x1)  =  isNat(x1)
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  x2
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  x4
uLength(x1, x2)  =  x2
proper(x1)  =  proper(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
[proper1, top] > [ok1, isNat1] > [tt, nil]
[proper1, top] > 0 > [tt, nil]
[proper1, top] > zeros > [tt, nil]

Status:
LENGTH1: [1]
ok1: [1]
tt: []
isNat1: [1]
0: []
zeros: []
nil: []
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(57) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(58) PisEmptyProof (EQUIVALENT transformation)

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

(59) TRUE

(60) Obligation:

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

S(ok(X)) → S(X)
S(mark(X)) → S(X)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(61) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


S(mark(X)) → S(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
S(x1)  =  x1
ok(x1)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x1, x2)
tt  =  tt
isNatIList(x1)  =  isNatIList
isNatList(x1)  =  isNatList
isNat(x1)  =  isNat
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  cons(x1, x2)
nil  =  nil
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  uTake2(x1, x2, x3, x4)
uLength(x1, x2)  =  uLength(x1, x2)
proper(x1)  =  x1
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
active1 > zeros > [and2, cons2] > mark1 > [tt, isNatIList, isNatList, isNat, 0]
active1 > nil > mark1 > [tt, isNatIList, isNatList, isNat, 0]
active1 > take2 > uTake24 > [and2, cons2] > mark1 > [tt, isNatIList, isNatList, isNat, 0]
active1 > uLength2 > mark1 > [tt, isNatIList, isNatList, isNat, 0]
top > [tt, isNatIList, isNatList, isNat, 0]

Status:
mark1: [1]
active1: [1]
and2: [1,2]
tt: []
isNatIList: []
isNatList: []
isNat: []
0: []
zeros: []
cons2: [1,2]
nil: []
take2: [2,1]
uTake24: [3,1,4,2]
uLength2: [2,1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(62) Obligation:

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

S(ok(X)) → S(X)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(63) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


S(ok(X)) → S(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
S(x1)  =  S(x1)
ok(x1)  =  ok(x1)
active(x1)  =  x1
and(x1, x2)  =  x2
tt  =  tt
mark(x1)  =  x1
isNatIList(x1)  =  x1
isNatList(x1)  =  x1
isNat(x1)  =  isNat(x1)
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  x2
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  x4
uLength(x1, x2)  =  x2
proper(x1)  =  proper(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
[proper1, top] > [ok1, isNat1] > [tt, nil]
[proper1, top] > 0 > [tt, nil]
[proper1, top] > zeros > [tt, nil]

Status:
S1: [1]
ok1: [1]
tt: []
isNat1: [1]
0: []
zeros: []
nil: []
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(64) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(65) PisEmptyProof (EQUIVALENT transformation)

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

(66) TRUE

(67) Obligation:

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

AND(X1, mark(X2)) → AND(X1, X2)
AND(mark(X1), X2) → AND(X1, X2)
AND(ok(X1), ok(X2)) → AND(X1, X2)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(68) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


AND(ok(X1), ok(X2)) → AND(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
AND(x1, x2)  =  AND(x2)
mark(x1)  =  x1
ok(x1)  =  ok(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x2)
tt  =  tt
isNatIList(x1)  =  isNatIList(x1)
isNatList(x1)  =  x1
isNat(x1)  =  x1
0  =  0
s(x1)  =  s(x1)
length(x1)  =  length(x1)
zeros  =  zeros
cons(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  take(x2)
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  uTake2(x4)
uLength(x1, x2)  =  uLength(x1, x2)
proper(x1)  =  proper(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
[tt, 0, zeros, nil] > [active1, take1, uTake21, proper1] > [and1, isNatIList1, s1] > [AND1, ok1]
[tt, 0, zeros, nil] > [active1, take1, uTake21, proper1] > [length1, uLength2] > [AND1, ok1]

Status:
AND1: [1]
ok1: [1]
active1: [1]
and1: [1]
tt: []
isNatIList1: [1]
0: []
s1: [1]
length1: [1]
zeros: []
nil: []
take1: [1]
uTake21: [1]
uLength2: [1,2]
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(69) Obligation:

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

AND(X1, mark(X2)) → AND(X1, X2)
AND(mark(X1), X2) → AND(X1, X2)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(70) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


AND(X1, mark(X2)) → AND(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
AND(x1, x2)  =  x2
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x1, x2)
tt  =  tt
isNatIList(x1)  =  isNatIList
isNatList(x1)  =  isNatList
isNat(x1)  =  isNat
0  =  0
s(x1)  =  x1
length(x1)  =  length(x1)
zeros  =  zeros
cons(x1, x2)  =  cons(x1, x2)
nil  =  nil
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  uTake2(x1, x2, x3, x4)
uLength(x1, x2)  =  uLength(x1, x2)
proper(x1)  =  x1
ok(x1)  =  ok
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
[active1, isNat, cons2] > and2 > [tt, isNatIList, isNatList, ok] > top > [mark1, length1]
[active1, isNat, cons2] > zeros > 0 > [tt, isNatIList, isNatList, ok] > top > [mark1, length1]
[active1, isNat, cons2] > nil > [tt, isNatIList, isNatList, ok] > top > [mark1, length1]
[active1, isNat, cons2] > uTake24 > take2 > [tt, isNatIList, isNatList, ok] > top > [mark1, length1]
[active1, isNat, cons2] > uLength2 > [tt, isNatIList, isNatList, ok] > top > [mark1, length1]

Status:
mark1: [1]
active1: [1]
and2: [2,1]
tt: []
isNatIList: []
isNatList: []
isNat: []
0: []
length1: [1]
zeros: []
cons2: [1,2]
nil: []
take2: [2,1]
uTake24: [1,2,4,3]
uLength2: [2,1]
ok: []
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(71) Obligation:

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

AND(mark(X1), X2) → AND(X1, X2)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(72) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


AND(mark(X1), X2) → AND(X1, X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
AND(x1, x2)  =  x1
mark(x1)  =  mark(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x1, x2)
tt  =  tt
isNatIList(x1)  =  isNatIList
isNatList(x1)  =  isNatList
isNat(x1)  =  isNat
0  =  0
s(x1)  =  s(x1)
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  cons(x1, x2)
nil  =  nil
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  uTake2(x1, x2, x3, x4)
uLength(x1, x2)  =  uLength(x1, x2)
proper(x1)  =  x1
ok(x1)  =  x1
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
[active1, take2, uTake24, top] > [and2, s1, cons2, uLength2] > [mark1, isNatIList, isNatList, isNat] > [tt, 0, nil]
zeros > [and2, s1, cons2, uLength2] > [mark1, isNatIList, isNatList, isNat] > [tt, 0, nil]

Status:
mark1: [1]
active1: [1]
and2: [1,2]
tt: []
isNatIList: []
isNatList: []
isNat: []
0: []
s1: [1]
zeros: []
cons2: [1,2]
nil: []
take2: [2,1]
uTake24: [3,2,4,1]
uLength2: [1,2]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(73) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(74) PisEmptyProof (EQUIVALENT transformation)

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

(75) TRUE

(76) Obligation:

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

PROPER(and(X1, X2)) → PROPER(X2)
PROPER(and(X1, X2)) → PROPER(X1)
PROPER(isNatIList(X)) → PROPER(X)
PROPER(isNatList(X)) → PROPER(X)
PROPER(isNat(X)) → PROPER(X)
PROPER(s(X)) → PROPER(X)
PROPER(length(X)) → PROPER(X)
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(take(X1, X2)) → PROPER(X1)
PROPER(take(X1, X2)) → PROPER(X2)
PROPER(uTake1(X)) → PROPER(X)
PROPER(uTake2(X1, X2, X3, X4)) → PROPER(X1)
PROPER(uTake2(X1, X2, X3, X4)) → PROPER(X2)
PROPER(uTake2(X1, X2, X3, X4)) → PROPER(X3)
PROPER(uTake2(X1, X2, X3, X4)) → PROPER(X4)
PROPER(uLength(X1, X2)) → PROPER(X1)
PROPER(uLength(X1, X2)) → PROPER(X2)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(77) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


PROPER(and(X1, X2)) → PROPER(X2)
PROPER(and(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X1)
PROPER(cons(X1, X2)) → PROPER(X2)
PROPER(take(X1, X2)) → PROPER(X1)
PROPER(take(X1, X2)) → PROPER(X2)
PROPER(uTake2(X1, X2, X3, X4)) → PROPER(X1)
PROPER(uTake2(X1, X2, X3, X4)) → PROPER(X2)
PROPER(uTake2(X1, X2, X3, X4)) → PROPER(X3)
PROPER(uTake2(X1, X2, X3, X4)) → PROPER(X4)
PROPER(uLength(X1, X2)) → PROPER(X1)
PROPER(uLength(X1, X2)) → PROPER(X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1)  =  x1
and(x1, x2)  =  and(x1, x2)
isNatIList(x1)  =  x1
isNatList(x1)  =  x1
isNat(x1)  =  x1
s(x1)  =  x1
length(x1)  =  x1
cons(x1, x2)  =  cons(x1, x2)
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  uTake2(x1, x2, x3, x4)
uLength(x1, x2)  =  uLength(x1, x2)
active(x1)  =  x1
tt  =  tt
mark(x1)  =  mark
0  =  0
zeros  =  zeros
nil  =  nil
proper(x1)  =  x1
ok(x1)  =  x1
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
and2 > [uLength2, tt, mark, 0]
zeros > [cons2, take2, uTake24] > [uLength2, tt, mark, 0]
nil > [uLength2, tt, mark, 0]
top > [uLength2, tt, mark, 0]

Status:
and2: [2,1]
cons2: [2,1]
take2: [2,1]
uTake24: [4,3,2,1]
uLength2: [2,1]
tt: []
mark: []
0: []
zeros: []
nil: []
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(78) Obligation:

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

PROPER(isNatIList(X)) → PROPER(X)
PROPER(isNatList(X)) → PROPER(X)
PROPER(isNat(X)) → PROPER(X)
PROPER(s(X)) → PROPER(X)
PROPER(length(X)) → PROPER(X)
PROPER(uTake1(X)) → PROPER(X)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(79) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


PROPER(isNatIList(X)) → PROPER(X)
PROPER(isNatList(X)) → PROPER(X)
PROPER(s(X)) → PROPER(X)
PROPER(length(X)) → PROPER(X)
PROPER(uTake1(X)) → PROPER(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1)  =  x1
isNatIList(x1)  =  isNatIList(x1)
isNatList(x1)  =  isNatList(x1)
isNat(x1)  =  x1
s(x1)  =  s(x1)
length(x1)  =  length(x1)
uTake1(x1)  =  uTake1(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x2)
tt  =  tt
mark(x1)  =  x1
0  =  0
zeros  =  zeros
cons(x1, x2)  =  x2
nil  =  nil
take(x1, x2)  =  take(x2)
uTake2(x1, x2, x3, x4)  =  uTake2(x4)
uLength(x1, x2)  =  uLength(x2)
proper(x1)  =  proper(x1)
ok(x1)  =  ok(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
top > proper1 > [isNatList1, length1, active1, and1, nil, uTake21, uLength1] > isNatIList1 > [tt, 0] > [s1, uTake11, take1, ok1]
top > proper1 > [isNatList1, length1, active1, and1, nil, uTake21, uLength1] > zeros > [s1, uTake11, take1, ok1]

Status:
isNatIList1: [1]
isNatList1: [1]
s1: [1]
length1: [1]
uTake11: [1]
active1: [1]
and1: [1]
tt: []
0: []
zeros: []
nil: []
take1: [1]
uTake21: [1]
uLength1: [1]
proper1: [1]
ok1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(80) Obligation:

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

PROPER(isNat(X)) → PROPER(X)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(81) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


PROPER(isNat(X)) → PROPER(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
PROPER(x1)  =  x1
isNat(x1)  =  isNat(x1)
active(x1)  =  active(x1)
and(x1, x2)  =  and(x1, x2)
tt  =  tt
mark(x1)  =  mark(x1)
isNatIList(x1)  =  isNatIList(x1)
isNatList(x1)  =  isNatList(x1)
0  =  0
s(x1)  =  x1
length(x1)  =  x1
zeros  =  zeros
cons(x1, x2)  =  cons(x1, x2)
nil  =  nil
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  uTake1(x1)
uTake2(x1, x2, x3, x4)  =  uTake2(x1, x2, x3, x4)
uLength(x1, x2)  =  uLength(x1, x2)
proper(x1)  =  proper(x1)
ok(x1)  =  x1
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
[active1, tt, 0, nil] > [and2, isNatIList1, isNatList1, take2, uTake11, uTake24, proper1] > [cons2, uLength2] > [isNat1, mark1, zeros, top]

Status:
isNat1: [1]
active1: [1]
and2: [2,1]
tt: []
mark1: [1]
isNatIList1: [1]
isNatList1: [1]
0: []
zeros: []
cons2: [1,2]
nil: []
take2: [1,2]
uTake11: [1]
uTake24: [1,4,3,2]
uLength2: [2,1]
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(82) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(83) PisEmptyProof (EQUIVALENT transformation)

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

(84) TRUE

(85) Obligation:

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

ACTIVE(and(X1, X2)) → ACTIVE(X2)
ACTIVE(and(X1, X2)) → ACTIVE(X1)
ACTIVE(s(X)) → ACTIVE(X)
ACTIVE(length(X)) → ACTIVE(X)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(take(X1, X2)) → ACTIVE(X1)
ACTIVE(take(X1, X2)) → ACTIVE(X2)
ACTIVE(uTake1(X)) → ACTIVE(X)
ACTIVE(uTake2(X1, X2, X3, X4)) → ACTIVE(X1)
ACTIVE(uLength(X1, X2)) → ACTIVE(X1)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(86) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ACTIVE(and(X1, X2)) → ACTIVE(X2)
ACTIVE(and(X1, X2)) → ACTIVE(X1)
ACTIVE(take(X1, X2)) → ACTIVE(X1)
ACTIVE(take(X1, X2)) → ACTIVE(X2)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1)  =  ACTIVE(x1)
and(x1, x2)  =  and(x1, x2)
s(x1)  =  x1
length(x1)  =  x1
cons(x1, x2)  =  x1
take(x1, x2)  =  take(x1, x2)
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  x1
uLength(x1, x2)  =  x1
active(x1)  =  active(x1)
tt  =  tt
mark(x1)  =  mark
isNatIList(x1)  =  x1
isNatList(x1)  =  isNatList(x1)
isNat(x1)  =  isNat(x1)
0  =  0
zeros  =  zeros
nil  =  nil
proper(x1)  =  proper(x1)
ok(x1)  =  ok(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
top > active1 > and2 > [tt, mark, 0, zeros, nil]
top > active1 > and2 > ok1
top > active1 > take2 > [isNatList1, isNat1] > [tt, mark, 0, zeros, nil]
top > active1 > take2 > [isNatList1, isNat1] > ok1
top > proper1 > and2 > [tt, mark, 0, zeros, nil]
top > proper1 > and2 > ok1
top > proper1 > take2 > [isNatList1, isNat1] > [tt, mark, 0, zeros, nil]
top > proper1 > take2 > [isNatList1, isNat1] > ok1

Status:
ACTIVE1: [1]
and2: [1,2]
take2: [2,1]
active1: [1]
tt: []
mark: []
isNatList1: [1]
isNat1: [1]
0: []
zeros: []
nil: []
proper1: [1]
ok1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(87) Obligation:

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

ACTIVE(s(X)) → ACTIVE(X)
ACTIVE(length(X)) → ACTIVE(X)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(uTake1(X)) → ACTIVE(X)
ACTIVE(uTake2(X1, X2, X3, X4)) → ACTIVE(X1)
ACTIVE(uLength(X1, X2)) → ACTIVE(X1)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(88) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ACTIVE(s(X)) → ACTIVE(X)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1)  =  x1
s(x1)  =  s(x1)
length(x1)  =  x1
cons(x1, x2)  =  x1
uTake1(x1)  =  x1
uTake2(x1, x2, x3, x4)  =  x1
uLength(x1, x2)  =  x1
active(x1)  =  x1
and(x1, x2)  =  and
tt  =  tt
mark(x1)  =  mark
isNatIList(x1)  =  isNatIList
isNatList(x1)  =  isNatList
isNat(x1)  =  isNat
0  =  0
zeros  =  zeros
nil  =  nil
take(x1, x2)  =  take(x2)
proper(x1)  =  proper(x1)
ok(x1)  =  x1
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
and > [s1, tt, mark, isNatIList, isNatList, isNat, nil, take1, proper1, top]
zeros > 0 > [s1, tt, mark, isNatIList, isNatList, isNat, nil, take1, proper1, top]

Status:
s1: [1]
and: []
tt: []
mark: []
isNatIList: []
isNatList: []
isNat: []
0: []
zeros: []
nil: []
take1: [1]
proper1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(89) Obligation:

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

ACTIVE(length(X)) → ACTIVE(X)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(uTake1(X)) → ACTIVE(X)
ACTIVE(uTake2(X1, X2, X3, X4)) → ACTIVE(X1)
ACTIVE(uLength(X1, X2)) → ACTIVE(X1)

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(90) QDPOrderProof (EQUIVALENT transformation)

We use the reduction pair processor [LPAR04].


The following pairs can be oriented strictly and are deleted.


ACTIVE(length(X)) → ACTIVE(X)
ACTIVE(cons(X1, X2)) → ACTIVE(X1)
ACTIVE(uTake1(X)) → ACTIVE(X)
ACTIVE(uTake2(X1, X2, X3, X4)) → ACTIVE(X1)
ACTIVE(uLength(X1, X2)) → ACTIVE(X1)
The remaining pairs can at least be oriented weakly.
Used ordering: Combined order from the following AFS and order.
ACTIVE(x1)  =  x1
length(x1)  =  length(x1)
cons(x1, x2)  =  cons(x1, x2)
uTake1(x1)  =  uTake1(x1)
uTake2(x1, x2, x3, x4)  =  uTake2(x1)
uLength(x1, x2)  =  uLength(x1, x2)
active(x1)  =  x1
and(x1, x2)  =  and(x2)
tt  =  tt
mark(x1)  =  mark
isNatIList(x1)  =  isNatIList(x1)
isNatList(x1)  =  isNatList(x1)
isNat(x1)  =  isNat(x1)
0  =  0
s(x1)  =  s(x1)
zeros  =  zeros
nil  =  nil
take(x1, x2)  =  take(x1)
proper(x1)  =  proper(x1)
ok(x1)  =  ok(x1)
top(x1)  =  top

Lexicographic path order with status [LPO].
Quasi-Precedence:
[cons2, proper1] > [uTake11, take1] > [length1, uTake21, and1, s1, ok1] > mark
[cons2, proper1] > uLength2 > [length1, uTake21, and1, s1, ok1] > mark
[cons2, proper1] > [isNatIList1, isNatList1] > isNat1 > [length1, uTake21, and1, s1, ok1] > mark
[cons2, proper1] > [isNatIList1, isNatList1] > isNat1 > tt
[cons2, proper1] > zeros > 0 > tt
[cons2, proper1] > zeros > 0 > mark
[cons2, proper1] > nil > [length1, uTake21, and1, s1, ok1] > mark
[cons2, proper1] > nil > tt

Status:
length1: [1]
cons2: [2,1]
uTake11: [1]
uTake21: [1]
uLength2: [1,2]
and1: [1]
tt: []
mark: []
isNatIList1: [1]
isNatList1: [1]
isNat1: [1]
0: []
s1: [1]
zeros: []
nil: []
take1: [1]
proper1: [1]
ok1: [1]
top: []


The following usable rules [FROCOS05] were oriented:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

(91) Obligation:

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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

(92) PisEmptyProof (EQUIVALENT transformation)

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

(93) TRUE

(94) Obligation:

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

TOP(ok(X)) → TOP(active(X))
TOP(mark(X)) → TOP(proper(X))

The TRS R consists of the following rules:

active(and(tt, T)) → mark(T)
active(isNatIList(IL)) → mark(isNatList(IL))
active(isNat(0)) → mark(tt)
active(isNat(s(N))) → mark(isNat(N))
active(isNat(length(L))) → mark(isNatList(L))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(N, L))) → mark(and(isNat(N), isNatList(L)))
active(isNatList(take(N, IL))) → mark(and(isNat(N), isNatIList(IL)))
active(zeros) → mark(cons(0, zeros))
active(take(0, IL)) → mark(uTake1(isNatIList(IL)))
active(uTake1(tt)) → mark(nil)
active(take(s(M), cons(N, IL))) → mark(uTake2(and(isNat(M), and(isNat(N), isNatIList(IL))), M, N, IL))
active(uTake2(tt, M, N, IL)) → mark(cons(N, take(M, IL)))
active(length(cons(N, L))) → mark(uLength(and(isNat(N), isNatList(L)), L))
active(uLength(tt, L)) → mark(s(length(L)))
active(and(X1, X2)) → and(active(X1), X2)
active(and(X1, X2)) → and(X1, active(X2))
active(s(X)) → s(active(X))
active(length(X)) → length(active(X))
active(cons(X1, X2)) → cons(active(X1), X2)
active(take(X1, X2)) → take(active(X1), X2)
active(take(X1, X2)) → take(X1, active(X2))
active(uTake1(X)) → uTake1(active(X))
active(uTake2(X1, X2, X3, X4)) → uTake2(active(X1), X2, X3, X4)
active(uLength(X1, X2)) → uLength(active(X1), X2)
and(mark(X1), X2) → mark(and(X1, X2))
and(X1, mark(X2)) → mark(and(X1, X2))
s(mark(X)) → mark(s(X))
length(mark(X)) → mark(length(X))
cons(mark(X1), X2) → mark(cons(X1, X2))
take(mark(X1), X2) → mark(take(X1, X2))
take(X1, mark(X2)) → mark(take(X1, X2))
uTake1(mark(X)) → mark(uTake1(X))
uTake2(mark(X1), X2, X3, X4) → mark(uTake2(X1, X2, X3, X4))
uLength(mark(X1), X2) → mark(uLength(X1, X2))
proper(and(X1, X2)) → and(proper(X1), proper(X2))
proper(tt) → ok(tt)
proper(isNatIList(X)) → isNatIList(proper(X))
proper(isNatList(X)) → isNatList(proper(X))
proper(isNat(X)) → isNat(proper(X))
proper(0) → ok(0)
proper(s(X)) → s(proper(X))
proper(length(X)) → length(proper(X))
proper(zeros) → ok(zeros)
proper(cons(X1, X2)) → cons(proper(X1), proper(X2))
proper(nil) → ok(nil)
proper(take(X1, X2)) → take(proper(X1), proper(X2))
proper(uTake1(X)) → uTake1(proper(X))
proper(uTake2(X1, X2, X3, X4)) → uTake2(proper(X1), proper(X2), proper(X3), proper(X4))
proper(uLength(X1, X2)) → uLength(proper(X1), proper(X2))
and(ok(X1), ok(X2)) → ok(and(X1, X2))
isNatIList(ok(X)) → ok(isNatIList(X))
isNatList(ok(X)) → ok(isNatList(X))
isNat(ok(X)) → ok(isNat(X))
s(ok(X)) → ok(s(X))
length(ok(X)) → ok(length(X))
cons(ok(X1), ok(X2)) → ok(cons(X1, X2))
take(ok(X1), ok(X2)) → ok(take(X1, X2))
uTake1(ok(X)) → ok(uTake1(X))
uTake2(ok(X1), ok(X2), ok(X3), ok(X4)) → ok(uTake2(X1, X2, X3, X4))
uLength(ok(X1), ok(X2)) → ok(uLength(X1, X2))
top(mark(X)) → top(proper(X))
top(ok(X)) → top(active(X))

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