Termination proof of ../tpdb/TRS/CSR_Maude/lazy-nat-list/OvConsOS

MAYBE Termination proof of ../tpdb/TRS/CSR_Maude/lazy-nat-list/OvConsOS_nokinds.trs
Termination of the following Term Rewriting System could not be shown:

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

zeros → cons(0, zeros)
U11(tt, L) → s(length(L))
U21(tt) → nil
U31(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → isNatList(V1)
isNat(s(V1)) → isNat(V1)
isNatIList(V) → isNatList(V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → and(isNat(V1), isNatIList(V2))
isNatList(nil) → tt
isNatList(cons(V1, V2)) → and(isNat(V1), isNatList(V2))
isNatList(take(V1, V2)) → and(isNat(V1), isNatIList(V2))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(L), isNat(N)), L)
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
s: {1}
length: {1}
U21: {1}
nil: empty set
U31: {1}
take: {1, 2}
and: {1}
isNat: empty set
isNatList: empty set
isNatIList: empty set

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

zeros → cons(0, zeros)
U11(tt, L) → s(length(L))
U21(tt) → nil
U31(tt, IL, M, N) → cons(N, take(M, IL))
and(tt, X) → X
isNat(0) → tt
isNat(length(V1)) → isNatList(V1)
isNat(s(V1)) → isNat(V1)
isNatIList(V) → isNatList(V)
isNatIList(zeros) → tt
isNatIList(cons(V1, V2)) → and(isNat(V1), isNatIList(V2))
isNatList(nil) → tt
isNatList(cons(V1, V2)) → and(isNat(V1), isNatList(V2))
isNatList(take(V1, V2)) → and(isNat(V1), isNatIList(V2))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(L), isNat(N)), L)
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N)

The replacement map contains the following entries:

zeros: empty set
cons: {1}
0: empty set
U11: {1}
tt: empty set
s: {1}
length: {1}
U21: {1}
nil: empty set
U31: {1}
take: {1, 2}
and: {1}
isNat: empty set
isNatList: empty set
isNatIList: empty set

We applied the Zantema [34] to transform the context-sensitive TRS to an usual TRS.

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

A(takeInact(x1, x2)) → TAKE(x1, x2)
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
A(zerosInact) → ZEROS
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
A(lengthInact(x1)) → LENGTH(x1)
A(andInact(x1, x2)) → AND(x1, x2)
TAKE(s(M), cons(N, IL)) → ISNATILIST(a(IL))
AND(tt, X) → A(X)
TAKE(s(M), cons(N, IL)) → U31¹(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
U31¹(tt, IL, M, N) → CONS(a(N), takeInact(a(M), a(IL)))
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
A(sInact(x1)) → S(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
ISNAT(lengthInact(V1)) → A(V1)
ISNATLIST(takeInact(V1, V2)) → ISNAT(a(V1))
ZEROS → 0¹
ZEROS → CONS(0, zerosInact)
ISNATLIST(takeInact(V1, V2)) → A(V2)
LENGTH(nil) → 0¹
TAKE(0, IL) → ISNATILIST(IL)
ISNATLIST(takeInact(V1, V2)) → A(V1)
ISNATILIST(V) → A(V)
A(nilInact) → NIL
TAKE(s(M), cons(N, IL)) → ISNAT(M)
TAKE(0, IL) → U21¹(isNatIList(IL))
ISNAT(sInact(V1)) → ISNAT(a(V1))
ISNATLIST(takeInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
U31¹(tt, IL, M, N) → A(N)
TAKE(s(M), cons(N, IL)) → AND(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N)))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
U11¹(tt, L) → LENGTH(a(L))
TAKE(s(M), cons(N, IL)) → A(IL)
A(0Inact) → 0¹
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
U11¹(tt, L) → S(length(a(L)))
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
U31¹(tt, IL, M, N) → A(M)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
U31¹(tt, IL, M, N) → A(IL)
ISNATILIST(V) → ISNATLIST(a(V))
A(consInact(x1, x2)) → CONS(x1, x2)
U21¹(tt) → NIL

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

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

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

A(takeInact(x1, x2)) → TAKE(x1, x2)
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
A(zerosInact) → ZEROS
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
A(lengthInact(x1)) → LENGTH(x1)
A(andInact(x1, x2)) → AND(x1, x2)
TAKE(s(M), cons(N, IL)) → ISNATILIST(a(IL))
AND(tt, X) → A(X)
TAKE(s(M), cons(N, IL)) → U31¹(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
U31¹(tt, IL, M, N) → CONS(a(N), takeInact(a(M), a(IL)))
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
A(sInact(x1)) → S(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
ISNAT(lengthInact(V1)) → A(V1)
ISNATLIST(takeInact(V1, V2)) → ISNAT(a(V1))
ZEROS → 0¹
ZEROS → CONS(0, zerosInact)
ISNATLIST(takeInact(V1, V2)) → A(V2)
LENGTH(nil) → 0¹
TAKE(0, IL) → ISNATILIST(IL)
ISNATLIST(takeInact(V1, V2)) → A(V1)
ISNATILIST(V) → A(V)
A(nilInact) → NIL
TAKE(s(M), cons(N, IL)) → ISNAT(M)
TAKE(0, IL) → U21¹(isNatIList(IL))
ISNAT(sInact(V1)) → ISNAT(a(V1))
ISNATLIST(takeInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
U31¹(tt, IL, M, N) → A(N)
TAKE(s(M), cons(N, IL)) → AND(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N)))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
U11¹(tt, L) → LENGTH(a(L))
TAKE(s(M), cons(N, IL)) → A(IL)
A(0Inact) → 0¹
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
U11¹(tt, L) → S(length(a(L)))
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
U31¹(tt, IL, M, N) → A(M)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
U31¹(tt, IL, M, N) → A(IL)
ISNATILIST(V) → ISNATLIST(a(V))
A(consInact(x1, x2)) → CONS(x1, x2)
U21¹(tt) → NIL

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 12 less nodes.

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

TAKE(s(M), cons(N, IL)) → ISNAT(M)
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
A(takeInact(x1, x2)) → TAKE(x1, x2)
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
ISNATLIST(takeInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
U31¹(tt, IL, M, N) → A(N)
TAKE(s(M), cons(N, IL)) → AND(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N)))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
A(lengthInact(x1)) → LENGTH(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
A(andInact(x1, x2)) → AND(x1, x2)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
TAKE(s(M), cons(N, IL)) → ISNATILIST(a(IL))
U11¹(tt, L) → LENGTH(a(L))
TAKE(s(M), cons(N, IL)) → U31¹(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
AND(tt, X) → A(X)
TAKE(s(M), cons(N, IL)) → A(IL)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
ISNAT(sInact(V1)) → A(V1)
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNAT(lengthInact(V1)) → A(V1)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
U31¹(tt, IL, M, N) → A(M)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
ISNATLIST(takeInact(V1, V2)) → ISNAT(a(V1))
U31¹(tt, IL, M, N) → A(IL)
ISNATILIST(V) → ISNATLIST(a(V))
ISNATLIST(takeInact(V1, V2)) → A(V2)
TAKE(0, IL) → ISNATILIST(IL)
ISNATLIST(takeInact(V1, V2)) → A(V1)
ISNATILIST(V) → A(V)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

A(takeInact(x1, x2)) → TAKE(x1, x2)
ISNATLIST(takeInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNATLIST(takeInact(V1, V2)) → ISNAT(a(V1))
ISNATLIST(takeInact(V1, V2)) → A(V2)
ISNATLIST(takeInact(V1, V2)) → A(V1)

The remaining pairs can at least be oriented weakly.

TAKE(s(M), cons(N, IL)) → ISNAT(M)
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
U31¹(tt, IL, M, N) → A(N)
TAKE(s(M), cons(N, IL)) → AND(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N)))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
A(lengthInact(x1)) → LENGTH(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
A(andInact(x1, x2)) → AND(x1, x2)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
TAKE(s(M), cons(N, IL)) → ISNATILIST(a(IL))
U11¹(tt, L) → LENGTH(a(L))
TAKE(s(M), cons(N, IL)) → U31¹(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
AND(tt, X) → A(X)
TAKE(s(M), cons(N, IL)) → A(IL)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
ISNAT(sInact(V1)) → A(V1)
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNAT(lengthInact(V1)) → A(V1)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
U31¹(tt, IL, M, N) → A(M)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
U31¹(tt, IL, M, N) → A(IL)
ISNATILIST(V) → ISNATLIST(a(V))
TAKE(0, IL) → ISNATILIST(IL)
ISNATILIST(V) → A(V)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(0Inact) = 0
POL(A(x₁)) = 1 + x₁
POL(AND(x₁, x₂)) = 1 + x₂
POL(ISNAT(x₁)) = 1 + x₁
POL(ISNATILIST(x₁)) = 1 + x₁
POL(ISNATLIST(x₁)) = 1 + x₁
POL(LENGTH(x₁)) = 1 + x₁
POL(TAKE(x₁, x₂)) = 1 + x₁ + x₂
POL(U11(x₁, x₂)) = x₁ + x₂
POL(U11¹(x₁, x₂)) = 1 + x₂
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 1 + x₂ + x₃ + x₄
POL(U31¹(x₁, x₂, x₃, x₄)) = 1 + x₂ + x₃ + x₄
POL(a(x₁)) = x₁
POL(and(x₁, x₂)) = x₂
POL(andInact(x₁, x₂)) = x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(consInact(x₁, x₂)) = x₁ + x₂
POL(isNat(x₁)) = x₁
POL(isNatIList(x₁)) = x₁
POL(isNatIListInact(x₁)) = x₁
POL(isNatInact(x₁)) = x₁
POL(isNatList(x₁)) = x₁
POL(isNatListInact(x₁)) = x₁
POL(length(x₁)) = x₁
POL(lengthInact(x₁)) = x₁
POL(nil) = 0
POL(nilInact) = 0
POL(s(x₁)) = x₁
POL(sInact(x₁)) = x₁
POL(take(x₁, x₂)) = 1 + x₁ + x₂
POL(takeInact(x₁, x₂)) = 1 + x₁ + x₂
POL(tt) = 0
POL(zeros) = 0
POL(zerosInact) = 0

The following usable rules [17] were oriented:

a(sInact(x1)) → s(x1)
a(x) → x
isNatList(x1) → isNatListInact(x1)
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
s(x1) → sInact(x1)
isNat(0Inact) → tt
a(zerosInact) → zeros
and(x1, x2) → andInact(x1, x2)
take(0, IL) → U21(isNatIList(IL))
0 → 0Inact
isNatIList(zerosInact) → tt
take(x1, x2) → takeInact(x1, x2)
a(lengthInact(x1)) → length(x1)
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(nilInact) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
length(nil) → 0
length(x1) → lengthInact(x1)
a(consInact(x1, x2)) → cons(x1, x2)
isNatList(nilInact) → tt
isNatIList(x1) → isNatIListInact(x1)
isNat(x1) → isNatInact(x1)
cons(x1, x2) → consInact(x1, x2)
zeros → cons(0, zerosInact)
a(takeInact(x1, x2)) → take(x1, x2)
a(isNatInact(x1)) → isNat(x1)
and(tt, X) → a(X)
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
a(isNatIListInact(x1)) → isNatIList(x1)
a(isNatListInact(x1)) → isNatList(x1)
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
a(andInact(x1, x2)) → and(x1, x2)
isNatIList(V) → isNatList(a(V))
isNat(lengthInact(V1)) → isNatList(a(V1))
U11(tt, L) → s(length(a(L)))
nil → nilInact
zeros → zerosInact
U21(tt) → nil
a(0Inact) → 0

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
TAKE(s(M), cons(N, IL)) → ISNAT(M)
ISNAT(sInact(V1)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
U31¹(tt, IL, M, N) → A(N)
TAKE(s(M), cons(N, IL)) → AND(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N)))
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
A(lengthInact(x1)) → LENGTH(x1)
A(andInact(x1, x2)) → AND(x1, x2)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
TAKE(s(M), cons(N, IL)) → ISNATILIST(a(IL))
U11¹(tt, L) → LENGTH(a(L))
TAKE(s(M), cons(N, IL)) → U31¹(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
AND(tt, X) → A(X)
TAKE(s(M), cons(N, IL)) → A(IL)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
ISNAT(sInact(V1)) → A(V1)
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
ISNAT(lengthInact(V1)) → A(V1)
U31¹(tt, IL, M, N) → A(M)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
U31¹(tt, IL, M, N) → A(IL)
ISNATILIST(V) → ISNATLIST(a(V))
TAKE(0, IL) → ISNATILIST(IL)
ISNATILIST(V) → A(V)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 9 less nodes.

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATLIST(consInact(V1, V2)) → A(V1)
A(lengthInact(x1)) → LENGTH(x1)
A(andInact(x1, x2)) → AND(x1, x2)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
U11¹(tt, L) → LENGTH(a(L))
AND(tt, X) → A(X)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
ISNAT(sInact(V1)) → A(V1)
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNAT(lengthInact(V1)) → A(V1)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
ISNATILIST(V) → ISNATLIST(a(V))
ISNATILIST(V) → A(V)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

A(lengthInact(x1)) → LENGTH(x1)
ISNAT(lengthInact(V1)) → A(V1)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))

The remaining pairs can at least be oriented weakly.

LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATLIST(consInact(V1, V2)) → A(V1)
A(andInact(x1, x2)) → AND(x1, x2)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
U11¹(tt, L) → LENGTH(a(L))
AND(tt, X) → A(X)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
ISNAT(sInact(V1)) → A(V1)
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
ISNATILIST(V) → ISNATLIST(a(V))
ISNATILIST(V) → A(V)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(0Inact) = 0
POL(A(x₁)) = x₁
POL(AND(x₁, x₂)) = x₂
POL(ISNAT(x₁)) = x₁
POL(ISNATILIST(x₁)) = x₁
POL(ISNATLIST(x₁)) = x₁
POL(LENGTH(x₁)) = x₁
POL(U11(x₁, x₂)) = 1 + x₂
POL(U11¹(x₁, x₂)) = x₂
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 1 + x₂ + x₄
POL(a(x₁)) = x₁
POL(and(x₁, x₂)) = x₂
POL(andInact(x₁, x₂)) = x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(consInact(x₁, x₂)) = x₁ + x₂
POL(isNat(x₁)) = x₁
POL(isNatIList(x₁)) = x₁
POL(isNatIListInact(x₁)) = x₁
POL(isNatInact(x₁)) = x₁
POL(isNatList(x₁)) = x₁
POL(isNatListInact(x₁)) = x₁
POL(length(x₁)) = 1 + x₁
POL(lengthInact(x₁)) = 1 + x₁
POL(nil) = 0
POL(nilInact) = 0
POL(s(x₁)) = x₁
POL(sInact(x₁)) = x₁
POL(take(x₁, x₂)) = 1 + x₂
POL(takeInact(x₁, x₂)) = 1 + x₂
POL(tt) = 0
POL(zeros) = 0
POL(zerosInact) = 0

The following usable rules [17] were oriented:

a(sInact(x1)) → s(x1)
a(x) → x
isNatList(x1) → isNatListInact(x1)
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
s(x1) → sInact(x1)
isNat(0Inact) → tt
a(zerosInact) → zeros
and(x1, x2) → andInact(x1, x2)
take(0, IL) → U21(isNatIList(IL))
0 → 0Inact
isNatIList(zerosInact) → tt
take(x1, x2) → takeInact(x1, x2)
a(lengthInact(x1)) → length(x1)
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(nilInact) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
length(nil) → 0
length(x1) → lengthInact(x1)
a(consInact(x1, x2)) → cons(x1, x2)
isNatList(nilInact) → tt
isNatIList(x1) → isNatIListInact(x1)
isNat(x1) → isNatInact(x1)
cons(x1, x2) → consInact(x1, x2)
zeros → cons(0, zerosInact)
a(takeInact(x1, x2)) → take(x1, x2)
a(isNatInact(x1)) → isNat(x1)
and(tt, X) → a(X)
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
a(isNatIListInact(x1)) → isNatIList(x1)
a(isNatListInact(x1)) → isNatList(x1)
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
a(andInact(x1, x2)) → and(x1, x2)
isNatIList(V) → isNatList(a(V))
isNat(lengthInact(V1)) → isNatList(a(V1))
U11(tt, L) → s(length(a(L)))
nil → nilInact
zeros → zerosInact
U21(tt) → nil
a(0Inact) → 0

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
ISNATILIST(V) → ISNATLIST(a(V))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATLIST(consInact(V1, V2)) → A(V1)
A(andInact(x1, x2)) → AND(x1, x2)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
ISNATILIST(V) → A(V)
U11¹(tt, L) → LENGTH(a(L))
AND(tt, X) → A(X)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 4 less nodes.

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                                ↳ QDPOrderProof

                              ↳ QDP

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(sInact(V1)) → ISNAT(a(V1))
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATILIST(V) → ISNATLIST(a(V))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
A(andInact(x1, x2)) → AND(x1, x2)
ISNATILIST(consInact(V1, V2)) → A(V1)
ISNATILIST(V) → A(V)
AND(tt, X) → A(X)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

A(isNatInact(x1)) → ISNAT(x1)

The remaining pairs can at least be oriented weakly.

ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(sInact(V1)) → ISNAT(a(V1))
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATILIST(V) → ISNATLIST(a(V))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
A(andInact(x1, x2)) → AND(x1, x2)
ISNATILIST(consInact(V1, V2)) → A(V1)
ISNATILIST(V) → A(V)
AND(tt, X) → A(X)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(0Inact) = 0
POL(A(x₁)) = x₁
POL(AND(x₁, x₂)) = x₂
POL(ISNAT(x₁)) = x₁
POL(ISNATILIST(x₁)) = x₁
POL(ISNATLIST(x₁)) = x₁
POL(U11(x₁, x₂)) = x₂
POL(U21(x₁)) = 1
POL(U31(x₁, x₂, x₃, x₄)) = 1 + x₂ + x₃ + x₄
POL(a(x₁)) = x₁
POL(and(x₁, x₂)) = x₂
POL(andInact(x₁, x₂)) = x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(consInact(x₁, x₂)) = x₁ + x₂
POL(isNat(x₁)) = 1 + x₁
POL(isNatIList(x₁)) = x₁
POL(isNatIListInact(x₁)) = x₁
POL(isNatInact(x₁)) = 1 + x₁
POL(isNatList(x₁)) = x₁
POL(isNatListInact(x₁)) = x₁
POL(length(x₁)) = x₁
POL(lengthInact(x₁)) = x₁
POL(nil) = 0
POL(nilInact) = 0
POL(s(x₁)) = x₁
POL(sInact(x₁)) = x₁
POL(take(x₁, x₂)) = 1 + x₁ + x₂
POL(takeInact(x₁, x₂)) = 1 + x₁ + x₂
POL(tt) = 0
POL(zeros) = 0
POL(zerosInact) = 0

The following usable rules [17] were oriented:

a(x) → x
a(sInact(x1)) → s(x1)
isNatList(x1) → isNatListInact(x1)
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
s(x1) → sInact(x1)
isNat(0Inact) → tt
a(zerosInact) → zeros
and(x1, x2) → andInact(x1, x2)
take(0, IL) → U21(isNatIList(IL))
0 → 0Inact
isNatIList(zerosInact) → tt
a(lengthInact(x1)) → length(x1)
take(x1, x2) → takeInact(x1, x2)
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(nilInact) → nil
length(nil) → 0
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
length(x1) → lengthInact(x1)
a(consInact(x1, x2)) → cons(x1, x2)
isNatList(nilInact) → tt
isNatIList(x1) → isNatIListInact(x1)
isNat(x1) → isNatInact(x1)
cons(x1, x2) → consInact(x1, x2)
zeros → cons(0, zerosInact)
a(takeInact(x1, x2)) → take(x1, x2)
a(isNatInact(x1)) → isNat(x1)
and(tt, X) → a(X)
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
a(isNatIListInact(x1)) → isNatIList(x1)
a(isNatListInact(x1)) → isNatList(x1)
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
a(andInact(x1, x2)) → and(x1, x2)
isNatIList(V) → isNatList(a(V))
isNat(lengthInact(V1)) → isNatList(a(V1))
U11(tt, L) → s(length(a(L)))
nil → nilInact
zeros → zerosInact
U21(tt) → nil
a(0Inact) → 0

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                              ↳ QDP

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(sInact(V1)) → ISNAT(a(V1))
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATILIST(V) → ISNATLIST(a(V))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
A(andInact(x1, x2)) → AND(x1, x2)
ISNATILIST(consInact(V1, V2)) → A(V1)
ISNATILIST(V) → A(V)
AND(tt, X) → A(X)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

ISNATILIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATILIST(V) → ISNATLIST(a(V))
ISNATILIST(consInact(V1, V2)) → A(V1)
ISNATILIST(V) → A(V)

The remaining pairs can at least be oriented weakly.

ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(sInact(V1)) → ISNAT(a(V1))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
A(andInact(x1, x2)) → AND(x1, x2)
AND(tt, X) → A(X)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(0Inact) = 0
POL(A(x₁)) = x₁
POL(AND(x₁, x₂)) = x₂
POL(ISNAT(x₁)) = x₁
POL(ISNATILIST(x₁)) = 1 + x₁
POL(ISNATLIST(x₁)) = x₁
POL(U11(x₁, x₂)) = x₂
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 1 + x₂ + x₃ + x₄
POL(a(x₁)) = x₁
POL(and(x₁, x₂)) = x₁ + x₂
POL(andInact(x₁, x₂)) = x₁ + x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(consInact(x₁, x₂)) = x₁ + x₂
POL(isNat(x₁)) = x₁
POL(isNatIList(x₁)) = 1 + x₁
POL(isNatIListInact(x₁)) = 1 + x₁
POL(isNatInact(x₁)) = x₁
POL(isNatList(x₁)) = x₁
POL(isNatListInact(x₁)) = x₁
POL(length(x₁)) = x₁
POL(lengthInact(x₁)) = x₁
POL(nil) = 0
POL(nilInact) = 0
POL(s(x₁)) = x₁
POL(sInact(x₁)) = x₁
POL(take(x₁, x₂)) = 1 + x₁ + x₂
POL(takeInact(x₁, x₂)) = 1 + x₁ + x₂
POL(tt) = 0
POL(zeros) = 0
POL(zerosInact) = 0

The following usable rules [17] were oriented:

a(x) → x
a(sInact(x1)) → s(x1)
isNatList(x1) → isNatListInact(x1)
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
s(x1) → sInact(x1)
isNat(0Inact) → tt
a(zerosInact) → zeros
and(x1, x2) → andInact(x1, x2)
take(0, IL) → U21(isNatIList(IL))
0 → 0Inact
isNatIList(zerosInact) → tt
a(lengthInact(x1)) → length(x1)
take(x1, x2) → takeInact(x1, x2)
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(nilInact) → nil
length(nil) → 0
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
length(x1) → lengthInact(x1)
a(consInact(x1, x2)) → cons(x1, x2)
isNatList(nilInact) → tt
isNatIList(x1) → isNatIListInact(x1)
isNat(x1) → isNatInact(x1)
cons(x1, x2) → consInact(x1, x2)
zeros → cons(0, zerosInact)
a(takeInact(x1, x2)) → take(x1, x2)
a(isNatInact(x1)) → isNat(x1)
and(tt, X) → a(X)
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
a(isNatIListInact(x1)) → isNatIList(x1)
a(isNatListInact(x1)) → isNatList(x1)
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
a(andInact(x1, x2)) → and(x1, x2)
isNatIList(V) → isNatList(a(V))
isNat(lengthInact(V1)) → isNatList(a(V1))
U11(tt, L) → s(length(a(L)))
nil → nilInact
zeros → zerosInact
U21(tt) → nil
a(0Inact) → 0

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                              ↳ QDP

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
ISNAT(sInact(V1)) → A(V1)
A(andInact(x1, x2)) → AND(x1, x2)
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(sInact(V1)) → ISNAT(a(V1))
AND(tt, X) → A(X)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATLIST(consInact(V1, V2)) → A(V2)

The remaining pairs can at least be oriented weakly.

A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
ISNAT(sInact(V1)) → A(V1)
A(andInact(x1, x2)) → AND(x1, x2)
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(sInact(V1)) → ISNAT(a(V1))
AND(tt, X) → A(X)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(0Inact) = 0
POL(A(x₁)) = x₁
POL(AND(x₁, x₂)) = x₂
POL(ISNAT(x₁)) = x₁
POL(ISNATILIST(x₁)) = 1 + x₁
POL(ISNATLIST(x₁)) = 1 + x₁
POL(U11(x₁, x₂)) = x₂
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = x₂ + x₃ + x₄
POL(a(x₁)) = x₁
POL(and(x₁, x₂)) = x₂
POL(andInact(x₁, x₂)) = x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(consInact(x₁, x₂)) = x₁ + x₂
POL(isNat(x₁)) = 1 + x₁
POL(isNatIList(x₁)) = 1 + x₁
POL(isNatIListInact(x₁)) = 1 + x₁
POL(isNatInact(x₁)) = 1 + x₁
POL(isNatList(x₁)) = 1 + x₁
POL(isNatListInact(x₁)) = 1 + x₁
POL(length(x₁)) = x₁
POL(lengthInact(x₁)) = x₁
POL(nil) = 0
POL(nilInact) = 0
POL(s(x₁)) = x₁
POL(sInact(x₁)) = x₁
POL(take(x₁, x₂)) = x₁ + x₂
POL(takeInact(x₁, x₂)) = x₁ + x₂
POL(tt) = 0
POL(zeros) = 0
POL(zerosInact) = 0

The following usable rules [17] were oriented:

a(x) → x
a(sInact(x1)) → s(x1)
isNatList(x1) → isNatListInact(x1)
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
s(x1) → sInact(x1)
isNat(0Inact) → tt
a(zerosInact) → zeros
and(x1, x2) → andInact(x1, x2)
take(0, IL) → U21(isNatIList(IL))
0 → 0Inact
isNatIList(zerosInact) → tt
a(lengthInact(x1)) → length(x1)
take(x1, x2) → takeInact(x1, x2)
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(nilInact) → nil
length(nil) → 0
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
length(x1) → lengthInact(x1)
a(consInact(x1, x2)) → cons(x1, x2)
isNatList(nilInact) → tt
isNatIList(x1) → isNatIListInact(x1)
isNat(x1) → isNatInact(x1)
cons(x1, x2) → consInact(x1, x2)
zeros → cons(0, zerosInact)
a(takeInact(x1, x2)) → take(x1, x2)
a(isNatInact(x1)) → isNat(x1)
and(tt, X) → a(X)
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
a(isNatIListInact(x1)) → isNatIList(x1)
a(isNatListInact(x1)) → isNatList(x1)
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
a(andInact(x1, x2)) → and(x1, x2)
isNatIList(V) → isNatList(a(V))
isNat(lengthInact(V1)) → isNatList(a(V1))
U11(tt, L) → s(length(a(L)))
nil → nilInact
zeros → zerosInact
U21(tt) → nil
a(0Inact) → 0

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                              ↳ QDP

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

A(isNatListInact(x1)) → ISNATLIST(x1)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
A(andInact(x1, x2)) → AND(x1, x2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(sInact(V1)) → ISNAT(a(V1))
AND(tt, X) → A(X)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 1 less node.

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                  ↳ QDPOrderProof

                                                ↳ QDP

                              ↳ QDP

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
A(andInact(x1, x2)) → AND(x1, x2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
AND(tt, X) → A(X)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

A(andInact(x1, x2)) → AND(x1, x2)

The remaining pairs can at least be oriented weakly.

A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
AND(tt, X) → A(X)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(0Inact) = 0
POL(A(x₁)) = x₁
POL(AND(x₁, x₂)) = x₂
POL(ISNATILIST(x₁)) = 0
POL(ISNATLIST(x₁)) = 0
POL(U11(x₁, x₂)) = 0
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 0
POL(a(x₁)) = 0
POL(and(x₁, x₂)) = 0
POL(andInact(x₁, x₂)) = 1 + x₁ + x₂
POL(cons(x₁, x₂)) = 0
POL(consInact(x₁, x₂)) = 0
POL(isNat(x₁)) = 0
POL(isNatIList(x₁)) = 0
POL(isNatIListInact(x₁)) = 0
POL(isNatInact(x₁)) = 0
POL(isNatList(x₁)) = 0
POL(isNatListInact(x₁)) = 0
POL(length(x₁)) = 0
POL(lengthInact(x₁)) = 0
POL(nil) = 0
POL(nilInact) = 0
POL(s(x₁)) = 0
POL(sInact(x₁)) = 0
POL(take(x₁, x₂)) = 0
POL(takeInact(x₁, x₂)) = 0
POL(tt) = 0
POL(zeros) = 0
POL(zerosInact) = 0

The following usable rules [17] were oriented: none

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                  ↳ QDPOrderProof

                                                    ↳ QDP

                                                ↳ QDP

                              ↳ QDP

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
AND(tt, X) → A(X)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

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

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ AND

                                                ↳ QDP

                                                ↳ QDP

                              ↳ QDP

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

ISNAT(sInact(V1)) → ISNAT(a(V1))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

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

↳ CSR

  ↳ Zantema-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                              ↳ QDP

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

U11¹(tt, L) → LENGTH(a(L))
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNat(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(x1, x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(x1)
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(x1)
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(x1, x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(x1, x2)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We applied the Incomplete Giesl Middeldorp [11] to transform the context-sensitive TRS to an usual TRS.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

MARK(take(x1, x2)) → MARK(x2)
MARK(U31(x1, x2, x3, x4)) → U31ACTIVE(mark(x1), x2, x3, x4)
TAKEACTIVE(0, IL) → U21ACTIVE(isNatIListActive(IL))
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
ISNATILISTACTIVE(V) → ISNATLISTACTIVE(V)
U11ACTIVE(tt, L) → MARK(L)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
TAKEACTIVE(s(M), cons(N, IL)) → ISNATILISTACTIVE(IL)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(U21(x1)) → MARK(x1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
U11ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
ANDACTIVE(tt, X) → MARK(X)
ISNATACTIVE(s(V1)) → ISNATACTIVE(V1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U31(x1, x2, x3, x4)) → MARK(x1)
TAKEACTIVE(s(M), cons(N, IL)) → U31ACTIVE(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)
U31ACTIVE(tt, IL, M, N) → MARK(N)
MARK(cons(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatList(V2))
MARK(and(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(isNatIListActive(IL), and(isNat(M), isNat(N)))
MARK(zeros) → ZEROSACTIVE
MARK(take(x1, x2)) → MARK(x1)
MARK(U21(x1)) → U21ACTIVE(mark(x1))
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATLISTACTIVE(take(V1, V2)) → ISNATACTIVE(V1)
MARK(s(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNat(N))
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U11(x1, x2)) → MARK(x1)
TAKEACTIVE(0, IL) → ISNATILISTACTIVE(IL)
ISNATACTIVE(length(V1)) → ISNATLISTACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

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

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

MARK(take(x1, x2)) → MARK(x2)
MARK(U31(x1, x2, x3, x4)) → U31ACTIVE(mark(x1), x2, x3, x4)
TAKEACTIVE(0, IL) → U21ACTIVE(isNatIListActive(IL))
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
ISNATILISTACTIVE(V) → ISNATLISTACTIVE(V)
U11ACTIVE(tt, L) → MARK(L)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
TAKEACTIVE(s(M), cons(N, IL)) → ISNATILISTACTIVE(IL)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(U21(x1)) → MARK(x1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
U11ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
ANDACTIVE(tt, X) → MARK(X)
ISNATACTIVE(s(V1)) → ISNATACTIVE(V1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U31(x1, x2, x3, x4)) → MARK(x1)
TAKEACTIVE(s(M), cons(N, IL)) → U31ACTIVE(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)
U31ACTIVE(tt, IL, M, N) → MARK(N)
MARK(cons(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatList(V2))
MARK(and(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(isNatIListActive(IL), and(isNat(M), isNat(N)))
MARK(zeros) → ZEROSACTIVE
MARK(take(x1, x2)) → MARK(x1)
MARK(U21(x1)) → U21ACTIVE(mark(x1))
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATLISTACTIVE(take(V1, V2)) → ISNATACTIVE(V1)
MARK(s(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNat(N))
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U11(x1, x2)) → MARK(x1)
TAKEACTIVE(0, IL) → ISNATILISTACTIVE(IL)
ISNATACTIVE(length(V1)) → ISNATLISTACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 3 less nodes.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

MARK(take(x1, x2)) → MARK(x2)
MARK(U31(x1, x2, x3, x4)) → U31ACTIVE(mark(x1), x2, x3, x4)
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
U11ACTIVE(tt, L) → MARK(L)
ISNATILISTACTIVE(V) → ISNATLISTACTIVE(V)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
TAKEACTIVE(s(M), cons(N, IL)) → ISNATILISTACTIVE(IL)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
MARK(U21(x1)) → MARK(x1)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
ANDACTIVE(tt, X) → MARK(X)
U11ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
ISNATACTIVE(s(V1)) → ISNATACTIVE(V1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U31(x1, x2, x3, x4)) → MARK(x1)
TAKEACTIVE(s(M), cons(N, IL)) → U31ACTIVE(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)
U31ACTIVE(tt, IL, M, N) → MARK(N)
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatList(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(isNatIListActive(IL), and(isNat(M), isNat(N)))
MARK(take(x1, x2)) → MARK(x1)
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATLISTACTIVE(take(V1, V2)) → ISNATACTIVE(V1)
MARK(s(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNat(N))
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U11(x1, x2)) → MARK(x1)
TAKEACTIVE(0, IL) → ISNATILISTACTIVE(IL)
ISNATACTIVE(length(V1)) → ISNATLISTACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

MARK(take(x1, x2)) → MARK(x2)
MARK(U31(x1, x2, x3, x4)) → U31ACTIVE(mark(x1), x2, x3, x4)
MARK(U21(x1)) → MARK(x1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U31(x1, x2, x3, x4)) → MARK(x1)
MARK(take(x1, x2)) → MARK(x1)

The remaining pairs can at least be oriented weakly.

ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
U11ACTIVE(tt, L) → MARK(L)
ISNATILISTACTIVE(V) → ISNATLISTACTIVE(V)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
TAKEACTIVE(s(M), cons(N, IL)) → ISNATILISTACTIVE(IL)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
ANDACTIVE(tt, X) → MARK(X)
U11ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
ISNATACTIVE(s(V1)) → ISNATACTIVE(V1)
TAKEACTIVE(s(M), cons(N, IL)) → U31ACTIVE(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)
U31ACTIVE(tt, IL, M, N) → MARK(N)
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatList(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(isNatIListActive(IL), and(isNat(M), isNat(N)))
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATLISTACTIVE(take(V1, V2)) → ISNATACTIVE(V1)
MARK(s(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNat(N))
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U11(x1, x2)) → MARK(x1)
TAKEACTIVE(0, IL) → ISNATILISTACTIVE(IL)
ISNATACTIVE(length(V1)) → ISNATLISTACTIVE(V1)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(ANDACTIVE(x₁, x₂)) = x₂
POL(ISNATACTIVE(x₁)) = 0
POL(ISNATILISTACTIVE(x₁)) = 0
POL(ISNATLISTACTIVE(x₁)) = 0
POL(LENGTHACTIVE(x₁)) = x₁
POL(MARK(x₁)) = x₁
POL(TAKEACTIVE(x₁, x₂)) = x₂
POL(U11(x₁, x₂)) = x₁ + x₂
POL(U11ACTIVE(x₁, x₂)) = x₂
POL(U11Active(x₁, x₂)) = x₁ + x₂
POL(U21(x₁)) = 1 + x₁
POL(U21Active(x₁)) = 1 + x₁
POL(U31(x₁, x₂, x₃, x₄)) = 1 + x₁ + x₂ + x₃ + x₄
POL(U31ACTIVE(x₁, x₂, x₃, x₄)) = x₄
POL(U31Active(x₁, x₂, x₃, x₄)) = 1 + x₁ + x₂ + x₃ + x₄
POL(and(x₁, x₂)) = x₁ + x₂
POL(andActive(x₁, x₂)) = x₁ + x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(isNat(x₁)) = 0
POL(isNatActive(x₁)) = 0
POL(isNatIList(x₁)) = 0
POL(isNatIListActive(x₁)) = 0
POL(isNatList(x₁)) = 0
POL(isNatListActive(x₁)) = 0
POL(length(x₁)) = x₁
POL(lengthActive(x₁)) = x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(s(x₁)) = x₁
POL(take(x₁, x₂)) = 1 + x₁ + x₂
POL(takeActive(x₁, x₂)) = 1 + x₁ + x₂
POL(tt) = 0
POL(zeros) = 0
POL(zerosActive) = 0

The following usable rules [17] were oriented:

lengthActive(x1) → length(x1)
isNatIListActive(zeros) → tt
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
lengthActive(nil) → 0
U11Active(tt, L) → s(lengthActive(mark(L)))
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
zerosActive → cons(0, zeros)
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)
U21Active(x1) → U21(x1)
mark(zeros) → zerosActive
isNatListActive(x1) → isNatList(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
isNatListActive(nil) → tt
mark(isNat(x1)) → isNatActive(x1)
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatActive(s(V1)) → isNatActive(V1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatIListActive(V) → isNatListActive(V)
isNatActive(length(V1)) → isNatListActive(V1)
mark(s(x1)) → s(mark(x1))
U21Active(tt) → nil
mark(tt) → tt
isNatIListActive(x1) → isNatIList(x1)
isNatActive(0) → tt
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(0) → 0
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
andActive(x1, x2) → and(x1, x2)
mark(nil) → nil
isNatActive(x1) → isNat(x1)
zerosActive → zeros
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
mark(U21(x1)) → U21Active(mark(x1))
takeActive(x1, x2) → take(x1, x2)

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
ISNATILISTACTIVE(V) → ISNATLISTACTIVE(V)
U11ACTIVE(tt, L) → MARK(L)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
TAKEACTIVE(s(M), cons(N, IL)) → ISNATILISTACTIVE(IL)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
U11ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
ANDACTIVE(tt, X) → MARK(X)
ISNATACTIVE(s(V1)) → ISNATACTIVE(V1)
TAKEACTIVE(s(M), cons(N, IL)) → U31ACTIVE(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)
U31ACTIVE(tt, IL, M, N) → MARK(N)
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatList(V2))
ISNATLISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)
TAKEACTIVE(s(M), cons(N, IL)) → ANDACTIVE(isNatIListActive(IL), and(isNat(M), isNat(N)))
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATLISTACTIVE(take(V1, V2)) → ISNATACTIVE(V1)
MARK(s(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNat(N))
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U11(x1, x2)) → MARK(x1)
TAKEACTIVE(0, IL) → ISNATILISTACTIVE(IL)
ISNATACTIVE(length(V1)) → ISNATLISTACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
U11ACTIVE(tt, L) → MARK(L)
ISNATILISTACTIVE(V) → ISNATLISTACTIVE(V)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
U11ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
ANDACTIVE(tt, X) → MARK(X)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
ISNATACTIVE(s(V1)) → ISNATACTIVE(V1)
MARK(cons(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatList(V2))
MARK(and(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)
MARK(length(x1)) → MARK(x1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATLISTACTIVE(take(V1, V2)) → ISNATACTIVE(V1)
MARK(s(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNat(N))
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U11(x1, x2)) → MARK(x1)
ISNATACTIVE(length(V1)) → ISNATLISTACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

MARK(U11(x1, x2)) → U11ACTIVE(mark(x1), x2)
MARK(length(x1)) → MARK(x1)
MARK(length(x1)) → LENGTHACTIVE(mark(x1))
MARK(U11(x1, x2)) → MARK(x1)

The remaining pairs can at least be oriented weakly.

ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
U11ACTIVE(tt, L) → MARK(L)
ISNATILISTACTIVE(V) → ISNATLISTACTIVE(V)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
U11ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
ANDACTIVE(tt, X) → MARK(X)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
ISNATACTIVE(s(V1)) → ISNATACTIVE(V1)
MARK(cons(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatList(V2))
MARK(and(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATLISTACTIVE(take(V1, V2)) → ISNATACTIVE(V1)
MARK(s(x1)) → MARK(x1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNat(N))
MARK(isNat(x1)) → ISNATACTIVE(x1)
ISNATACTIVE(length(V1)) → ISNATLISTACTIVE(V1)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(ANDACTIVE(x₁, x₂)) = x₂
POL(ISNATACTIVE(x₁)) = 0
POL(ISNATILISTACTIVE(x₁)) = 0
POL(ISNATLISTACTIVE(x₁)) = 0
POL(LENGTHACTIVE(x₁)) = x₁
POL(MARK(x₁)) = x₁
POL(U11(x₁, x₂)) = 1 + x₁ + x₂
POL(U11ACTIVE(x₁, x₂)) = x₂
POL(U11Active(x₁, x₂)) = 1 + x₁ + x₂
POL(U21(x₁)) = 0
POL(U21Active(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 1 + x₂ + x₄
POL(U31Active(x₁, x₂, x₃, x₄)) = 1 + x₂ + x₄
POL(and(x₁, x₂)) = x₁ + x₂
POL(andActive(x₁, x₂)) = x₁ + x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(isNat(x₁)) = 0
POL(isNatActive(x₁)) = 0
POL(isNatIList(x₁)) = 0
POL(isNatIListActive(x₁)) = 0
POL(isNatList(x₁)) = 0
POL(isNatListActive(x₁)) = 0
POL(length(x₁)) = 1 + x₁
POL(lengthActive(x₁)) = 1 + x₁
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(s(x₁)) = x₁
POL(take(x₁, x₂)) = 1 + x₂
POL(takeActive(x₁, x₂)) = 1 + x₂
POL(tt) = 0
POL(zeros) = 0
POL(zerosActive) = 0

The following usable rules [17] were oriented:

lengthActive(x1) → length(x1)
isNatIListActive(zeros) → tt
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
lengthActive(nil) → 0
U11Active(tt, L) → s(lengthActive(mark(L)))
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
zerosActive → cons(0, zeros)
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)
U21Active(x1) → U21(x1)
mark(zeros) → zerosActive
isNatListActive(x1) → isNatList(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
isNatListActive(nil) → tt
mark(isNat(x1)) → isNatActive(x1)
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatActive(s(V1)) → isNatActive(V1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatIListActive(V) → isNatListActive(V)
isNatActive(length(V1)) → isNatListActive(V1)
mark(s(x1)) → s(mark(x1))
U21Active(tt) → nil
mark(tt) → tt
isNatIListActive(x1) → isNatIList(x1)
isNatActive(0) → tt
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(0) → 0
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
andActive(x1, x2) → and(x1, x2)
mark(nil) → nil
isNatActive(x1) → isNat(x1)
zerosActive → zeros
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
mark(U21(x1)) → U21Active(mark(x1))
takeActive(x1, x2) → take(x1, x2)

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

MARK(and(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatList(V2))
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
U11ACTIVE(tt, L) → MARK(L)
ISNATILISTACTIVE(V) → ISNATLISTACTIVE(V)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)
LENGTHACTIVE(cons(N, L)) → ISNATLISTACTIVE(L)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATLISTACTIVE(take(V1, V2)) → ISNATACTIVE(V1)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
ANDACTIVE(tt, X) → MARK(X)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
ISNATACTIVE(s(V1)) → ISNATACTIVE(V1)
LENGTHACTIVE(cons(N, L)) → ANDACTIVE(isNatListActive(L), isNat(N))
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(cons(x1, x2)) → MARK(x1)
ISNATACTIVE(length(V1)) → ISNATLISTACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 3 less nodes.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                                ↳ QDPOrderProof

                              ↳ QDP

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

MARK(and(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatList(V2))
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
ISNATILISTACTIVE(V) → ISNATLISTACTIVE(V)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATLISTACTIVE(take(V1, V2)) → ISNATACTIVE(V1)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(s(x1)) → MARK(x1)
ANDACTIVE(tt, X) → MARK(X)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
ISNATACTIVE(s(V1)) → ISNATACTIVE(V1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(cons(x1, x2)) → MARK(x1)
ISNATACTIVE(length(V1)) → ISNATLISTACTIVE(V1)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

MARK(and(x1, x2)) → MARK(x1)
ISNATLISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
ISNATILISTACTIVE(cons(V1, V2)) → ISNATACTIVE(V1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
ISNATLISTACTIVE(take(V1, V2)) → ISNATACTIVE(V1)
MARK(isNatList(x1)) → ISNATLISTACTIVE(x1)
MARK(s(x1)) → MARK(x1)
MARK(isNatIList(x1)) → ISNATILISTACTIVE(x1)
ISNATACTIVE(s(V1)) → ISNATACTIVE(V1)
MARK(isNat(x1)) → ISNATACTIVE(x1)
MARK(cons(x1, x2)) → MARK(x1)
ISNATACTIVE(length(V1)) → ISNATLISTACTIVE(V1)

The remaining pairs can at least be oriented weakly.

ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatList(V2))
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
ISNATILISTACTIVE(V) → ISNATLISTACTIVE(V)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
ANDACTIVE(tt, X) → MARK(X)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(ANDACTIVE(x₁, x₂)) = 1 + x₂
POL(ISNATACTIVE(x₁)) = 1 + x₁
POL(ISNATILISTACTIVE(x₁)) = 1 + x₁
POL(ISNATLISTACTIVE(x₁)) = 1 + x₁
POL(MARK(x₁)) = 1 + x₁
POL(U11(x₁, x₂)) = 0
POL(U11Active(x₁, x₂)) = 0
POL(U21(x₁)) = 0
POL(U21Active(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 0
POL(U31Active(x₁, x₂, x₃, x₄)) = 0
POL(and(x₁, x₂)) = 1 + x₁ + x₂
POL(andActive(x₁, x₂)) = 0
POL(cons(x₁, x₂)) = 1 + x₁ + x₂
POL(isNat(x₁)) = 1 + x₁
POL(isNatActive(x₁)) = 0
POL(isNatIList(x₁)) = 1 + x₁
POL(isNatIListActive(x₁)) = 0
POL(isNatList(x₁)) = 1 + x₁
POL(isNatListActive(x₁)) = 0
POL(length(x₁)) = 1 + x₁
POL(lengthActive(x₁)) = 0
POL(mark(x₁)) = 0
POL(nil) = 0
POL(s(x₁)) = 1 + x₁
POL(take(x₁, x₂)) = 1 + x₁ + x₂
POL(takeActive(x₁, x₂)) = 0
POL(tt) = 0
POL(zeros) = 0
POL(zerosActive) = 0

The following usable rules [17] were oriented: none

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                              ↳ QDP

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

ISNATLISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatList(V2))
ISNATLISTACTIVE(take(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))
ISNATILISTACTIVE(V) → ISNATLISTACTIVE(V)
ANDACTIVE(tt, X) → MARK(X)
ISNATILISTACTIVE(cons(V1, V2)) → ANDACTIVE(isNatActive(V1), isNatIList(V2))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 5 less nodes.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                              ↳ QDP

                                ↳ Narrowing

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

U11ACTIVE(tt, L) → LENGTHACTIVE(mark(L))
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule U11ACTIVE(tt, L) → LENGTHACTIVE(mark(L)) at position [0] we obtained the following new rules:

U11ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
U11ACTIVE(tt, U11(x0, x1)) → LENGTHACTIVE(U11Active(mark(x0), x1))
U11ACTIVE(tt, length(x0)) → LENGTHACTIVE(lengthActive(mark(x0)))
U11ACTIVE(tt, zeros) → LENGTHACTIVE(zerosActive)
U11ACTIVE(tt, tt) → LENGTHACTIVE(tt)
U11ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U11ACTIVE(tt, U31(x0, x1, x2, x3)) → LENGTHACTIVE(U31Active(mark(x0), x1, x2, x3))
U11ACTIVE(tt, U21(x0)) → LENGTHACTIVE(U21Active(mark(x0)))
U11ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, 0) → LENGTHACTIVE(0)
U11ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, nil) → LENGTHACTIVE(nil)
U11ACTIVE(tt, s(x0)) → LENGTHACTIVE(s(mark(x0)))
U11ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))
U11ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

U11ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
U11ACTIVE(tt, U11(x0, x1)) → LENGTHACTIVE(U11Active(mark(x0), x1))
U11ACTIVE(tt, length(x0)) → LENGTHACTIVE(lengthActive(mark(x0)))
U11ACTIVE(tt, zeros) → LENGTHACTIVE(zerosActive)
U11ACTIVE(tt, tt) → LENGTHACTIVE(tt)
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)
U11ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U11ACTIVE(tt, U31(x0, x1, x2, x3)) → LENGTHACTIVE(U31Active(mark(x0), x1, x2, x3))
U11ACTIVE(tt, U21(x0)) → LENGTHACTIVE(U21Active(mark(x0)))
U11ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, 0) → LENGTHACTIVE(0)
U11ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, s(x0)) → LENGTHACTIVE(s(mark(x0)))
U11ACTIVE(tt, nil) → LENGTHACTIVE(nil)
U11ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
U11ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

U11ACTIVE(tt, length(x0)) → LENGTHACTIVE(lengthActive(mark(x0)))
U11ACTIVE(tt, U11(x0, x1)) → LENGTHACTIVE(U11Active(mark(x0), x1))
U11ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
U11ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, zeros) → LENGTHACTIVE(zerosActive)
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)
U11ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U11ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
U11ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))
U11ACTIVE(tt, U21(x0)) → LENGTHACTIVE(U21Active(mark(x0)))
U11ACTIVE(tt, U31(x0, x1, x2, x3)) → LENGTHACTIVE(U31Active(mark(x0), x1, x2, x3))
U11ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

U11ACTIVE(tt, length(x0)) → LENGTHACTIVE(lengthActive(mark(x0)))
U11ACTIVE(tt, U11(x0, x1)) → LENGTHACTIVE(U11Active(mark(x0), x1))
U11ACTIVE(tt, U21(x0)) → LENGTHACTIVE(U21Active(mark(x0)))

The remaining pairs can at least be oriented weakly.

U11ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
U11ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, zeros) → LENGTHACTIVE(zerosActive)
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)
U11ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U11ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
U11ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))
U11ACTIVE(tt, U31(x0, x1, x2, x3)) → LENGTHACTIVE(U31Active(mark(x0), x1, x2, x3))
U11ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(LENGTHACTIVE(x₁)) = x₁
POL(U11(x₁, x₂)) = 0
POL(U11ACTIVE(x₁, x₂)) = 1
POL(U11Active(x₁, x₂)) = 0
POL(U21(x₁)) = 0
POL(U21Active(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 0
POL(U31Active(x₁, x₂, x₃, x₄)) = x₁
POL(and(x₁, x₂)) = 0
POL(andActive(x₁, x₂)) = 1
POL(cons(x₁, x₂)) = 1
POL(isNat(x₁)) = 0
POL(isNatActive(x₁)) = 1
POL(isNatIList(x₁)) = 0
POL(isNatIListActive(x₁)) = 1
POL(isNatList(x₁)) = 0
POL(isNatListActive(x₁)) = 1
POL(length(x₁)) = 0
POL(lengthActive(x₁)) = 0
POL(mark(x₁)) = 1
POL(nil) = 0
POL(s(x₁)) = 0
POL(take(x₁, x₂)) = 0
POL(takeActive(x₁, x₂)) = 1
POL(tt) = 1
POL(zeros) = 0
POL(zerosActive) = 1

The following usable rules [17] were oriented:

lengthActive(x1) → length(x1)
isNatIListActive(zeros) → tt
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
lengthActive(nil) → 0
U11Active(tt, L) → s(lengthActive(mark(L)))
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
zerosActive → cons(0, zeros)
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)
U21Active(x1) → U21(x1)
mark(zeros) → zerosActive
isNatListActive(x1) → isNatList(x1)
mark(cons(x1, x2)) → cons(mark(x1), x2)
isNatListActive(nil) → tt
mark(isNat(x1)) → isNatActive(x1)
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(tt, X) → mark(X)
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatActive(s(V1)) → isNatActive(V1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatIListActive(V) → isNatListActive(V)
isNatActive(length(V1)) → isNatListActive(V1)
mark(s(x1)) → s(mark(x1))
U21Active(tt) → nil
mark(tt) → tt
isNatIListActive(x1) → isNatIList(x1)
isNatActive(0) → tt
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
mark(0) → 0
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
mark(nil) → nil
andActive(x1, x2) → and(x1, x2)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
isNatActive(x1) → isNat(x1)
zerosActive → zeros
mark(length(x1)) → lengthActive(mark(x1))
mark(U21(x1)) → U21Active(mark(x1))
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(x1, x2) → take(x1, x2)

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                              ↳ QDP

                                ↳ Narrowing

                                  ↳ QDP

                                    ↳ DependencyGraphProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

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

U11ACTIVE(tt, isNat(x0)) → LENGTHACTIVE(isNatActive(x0))
U11ACTIVE(tt, and(x0, x1)) → LENGTHACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, zeros) → LENGTHACTIVE(zerosActive)
LENGTHACTIVE(cons(N, L)) → U11ACTIVE(andActive(isNatListActive(L), isNat(N)), L)
U11ACTIVE(tt, isNatIList(x0)) → LENGTHACTIVE(isNatIListActive(x0))
U11ACTIVE(tt, U31(x0, x1, x2, x3)) → LENGTHACTIVE(U31Active(mark(x0), x1, x2, x3))
U11ACTIVE(tt, isNatList(x0)) → LENGTHACTIVE(isNatListActive(x0))
U11ACTIVE(tt, cons(x0, x1)) → LENGTHACTIVE(cons(mark(x0), x1))
U11ACTIVE(tt, take(x0, x1)) → LENGTHACTIVE(takeActive(mark(x0), mark(x1)))

The TRS R consists of the following rules:

mark(zeros) → zerosActive
zerosActive → zeros
mark(U11(x1, x2)) → U11Active(mark(x1), x2)
U11Active(x1, x2) → U11(x1, x2)
mark(U21(x1)) → U21Active(mark(x1))
U21Active(x1) → U21(x1)
mark(U31(x1, x2, x3, x4)) → U31Active(mark(x1), x2, x3, x4)
U31Active(x1, x2, x3, x4) → U31(x1, x2, x3, x4)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(isNat(x1)) → isNatActive(x1)
isNatActive(x1) → isNat(x1)
mark(isNatIList(x1)) → isNatIListActive(x1)
isNatIListActive(x1) → isNatIList(x1)
mark(isNatList(x1)) → isNatListActive(x1)
isNatListActive(x1) → isNatList(x1)
mark(length(x1)) → lengthActive(mark(x1))
lengthActive(x1) → length(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(0) → 0
mark(tt) → tt
mark(s(x1)) → s(mark(x1))
mark(nil) → nil
zerosActive → cons(0, zeros)
U11Active(tt, L) → s(lengthActive(mark(L)))
U21Active(tt) → nil
U31Active(tt, IL, M, N) → cons(mark(N), take(M, IL))
andActive(tt, X) → mark(X)
isNatActive(0) → tt
isNatActive(length(V1)) → isNatListActive(V1)
isNatActive(s(V1)) → isNatActive(V1)
isNatIListActive(V) → isNatListActive(V)
isNatIListActive(zeros) → tt
isNatIListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
isNatListActive(nil) → tt
isNatListActive(cons(V1, V2)) → andActive(isNatActive(V1), isNatList(V2))
isNatListActive(take(V1, V2)) → andActive(isNatActive(V1), isNatIList(V2))
lengthActive(nil) → 0
lengthActive(cons(N, L)) → U11Active(andActive(isNatListActive(L), isNat(N)), L)
takeActive(0, IL) → U21Active(isNatIListActive(IL))
takeActive(s(M), cons(N, IL)) → U31Active(andActive(isNatIListActive(IL), and(isNat(M), isNat(N))), IL, M, N)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We applied the Improved Ferreira Ribeiro [5,11] to transform the context-sensitive TRS to an usual TRS.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

  ↳ Complete Giesl Middeldorp-Transformation

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

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(a(x1), x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(a(x1))
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(a(x1))
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(a(x1), x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

TAKE(s(M), cons(N, IL)) → U31¹(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
A(zerosInact) → ZEROS
LENGTH(cons(N, L)) → ISNATLIST(a(L))
A(sInact(x1)) → S(a(x1))
A(sInact(x1)) → A(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
TAKE(s(M), cons(N, IL)) → ISNATILIST(a(IL))
AND(tt, X) → A(X)
U31¹(tt, IL, M, N) → CONS(a(N), takeInact(a(M), a(IL)))
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
A(consInact(x1, x2)) → A(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
ISNAT(lengthInact(V1)) → A(V1)
A(takeInact(x1, x2)) → A(x2)
ISNATLIST(takeInact(V1, V2)) → ISNAT(a(V1))
ZEROS → 0¹
A(takeInact(x1, x2)) → A(x1)
ZEROS → CONS(0, zerosInact)
A(lengthInact(x1)) → LENGTH(a(x1))
ISNATLIST(takeInact(V1, V2)) → A(V2)
LENGTH(nil) → 0¹
TAKE(0, IL) → ISNATILIST(IL)
TAKE(s(M), cons(N, IL)) → AND(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N)))
ISNATLIST(takeInact(V1, V2)) → A(V1)
ISNATILIST(V) → A(V)
A(nilInact) → NIL
A(andInact(x1, x2)) → AND(a(x1), x2)
TAKE(0, IL) → U21¹(isNatIList(IL))
ISNAT(sInact(V1)) → ISNAT(a(V1))
ISNATLIST(takeInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
U31¹(tt, IL, M, N) → A(N)
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
U11¹(tt, L) → LENGTH(a(L))
A(lengthInact(x1)) → A(x1)
TAKE(s(M), cons(N, IL)) → A(IL)
A(0Inact) → 0¹
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
A(consInact(x1, x2)) → CONS(a(x1), x2)
LENGTH(cons(N, L)) → A(L)
U11¹(tt, L) → S(length(a(L)))
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
A(andInact(x1, x2)) → A(x1)
U31¹(tt, IL, M, N) → A(M)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
U31¹(tt, IL, M, N) → A(IL)
ISNATILIST(V) → ISNATLIST(a(V))
U21¹(tt) → NIL
A(takeInact(x1, x2)) → TAKE(a(x1), a(x2))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(a(x1), x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(a(x1))
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(a(x1))
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(a(x1), x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

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

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

  ↳ Complete Giesl Middeldorp-Transformation

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

TAKE(s(M), cons(N, IL)) → U31¹(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
A(zerosInact) → ZEROS
LENGTH(cons(N, L)) → ISNATLIST(a(L))
A(sInact(x1)) → S(a(x1))
A(sInact(x1)) → A(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
TAKE(s(M), cons(N, IL)) → ISNATILIST(a(IL))
AND(tt, X) → A(X)
U31¹(tt, IL, M, N) → CONS(a(N), takeInact(a(M), a(IL)))
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
A(consInact(x1, x2)) → A(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
ISNAT(lengthInact(V1)) → A(V1)
A(takeInact(x1, x2)) → A(x2)
ISNATLIST(takeInact(V1, V2)) → ISNAT(a(V1))
ZEROS → 0¹
A(takeInact(x1, x2)) → A(x1)
ZEROS → CONS(0, zerosInact)
A(lengthInact(x1)) → LENGTH(a(x1))
ISNATLIST(takeInact(V1, V2)) → A(V2)
LENGTH(nil) → 0¹
TAKE(0, IL) → ISNATILIST(IL)
TAKE(s(M), cons(N, IL)) → AND(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N)))
ISNATLIST(takeInact(V1, V2)) → A(V1)
ISNATILIST(V) → A(V)
A(nilInact) → NIL
A(andInact(x1, x2)) → AND(a(x1), x2)
TAKE(0, IL) → U21¹(isNatIList(IL))
ISNAT(sInact(V1)) → ISNAT(a(V1))
ISNATLIST(takeInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
U31¹(tt, IL, M, N) → A(N)
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
U11¹(tt, L) → LENGTH(a(L))
A(lengthInact(x1)) → A(x1)
TAKE(s(M), cons(N, IL)) → A(IL)
A(0Inact) → 0¹
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
A(consInact(x1, x2)) → CONS(a(x1), x2)
LENGTH(cons(N, L)) → A(L)
U11¹(tt, L) → S(length(a(L)))
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
A(andInact(x1, x2)) → A(x1)
U31¹(tt, IL, M, N) → A(M)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
U31¹(tt, IL, M, N) → A(IL)
ISNATILIST(V) → ISNATLIST(a(V))
U21¹(tt) → NIL
A(takeInact(x1, x2)) → TAKE(a(x1), a(x2))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(a(x1), x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(a(x1))
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(a(x1))
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(a(x1), x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 12 less nodes.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

  ↳ Complete Giesl Middeldorp-Transformation

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

TAKE(s(M), cons(N, IL)) → U31¹(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
ISNAT(sInact(V1)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNATLIST(takeInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
U31¹(tt, IL, M, N) → A(N)
A(sInact(x1)) → A(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
TAKE(s(M), cons(N, IL)) → ISNATILIST(a(IL))
U11¹(tt, L) → LENGTH(a(L))
AND(tt, X) → A(X)
A(lengthInact(x1)) → A(x1)
TAKE(s(M), cons(N, IL)) → A(IL)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
A(consInact(x1, x2)) → A(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(lengthInact(V1)) → A(V1)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
A(takeInact(x1, x2)) → A(x2)
A(andInact(x1, x2)) → A(x1)
U31¹(tt, IL, M, N) → A(M)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
ISNATLIST(takeInact(V1, V2)) → ISNAT(a(V1))
U31¹(tt, IL, M, N) → A(IL)
ISNATILIST(V) → ISNATLIST(a(V))
A(takeInact(x1, x2)) → A(x1)
A(lengthInact(x1)) → LENGTH(a(x1))
ISNATLIST(takeInact(V1, V2)) → A(V2)
TAKE(s(M), cons(N, IL)) → AND(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N)))
TAKE(0, IL) → ISNATILIST(IL)
ISNATLIST(takeInact(V1, V2)) → A(V1)
A(takeInact(x1, x2)) → TAKE(a(x1), a(x2))
ISNATILIST(V) → A(V)
A(andInact(x1, x2)) → AND(a(x1), x2)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(a(x1), x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(a(x1))
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(a(x1))
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(a(x1), x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

ISNATLIST(takeInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
A(takeInact(x1, x2)) → A(x2)
ISNATLIST(takeInact(V1, V2)) → ISNAT(a(V1))
A(takeInact(x1, x2)) → A(x1)
ISNATLIST(takeInact(V1, V2)) → A(V2)
ISNATLIST(takeInact(V1, V2)) → A(V1)
A(takeInact(x1, x2)) → TAKE(a(x1), a(x2))

The remaining pairs can at least be oriented weakly.

TAKE(s(M), cons(N, IL)) → U31¹(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
ISNAT(sInact(V1)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
U31¹(tt, IL, M, N) → A(N)
A(sInact(x1)) → A(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
TAKE(s(M), cons(N, IL)) → ISNATILIST(a(IL))
U11¹(tt, L) → LENGTH(a(L))
AND(tt, X) → A(X)
A(lengthInact(x1)) → A(x1)
TAKE(s(M), cons(N, IL)) → A(IL)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
A(consInact(x1, x2)) → A(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(lengthInact(V1)) → A(V1)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
A(andInact(x1, x2)) → A(x1)
U31¹(tt, IL, M, N) → A(M)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
U31¹(tt, IL, M, N) → A(IL)
ISNATILIST(V) → ISNATLIST(a(V))
A(lengthInact(x1)) → LENGTH(a(x1))
TAKE(s(M), cons(N, IL)) → AND(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N)))
TAKE(0, IL) → ISNATILIST(IL)
ISNATILIST(V) → A(V)
A(andInact(x1, x2)) → AND(a(x1), x2)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(0Inact) = 0
POL(A(x₁)) = x₁
POL(AND(x₁, x₂)) = x₂
POL(ISNAT(x₁)) = x₁
POL(ISNATILIST(x₁)) = x₁
POL(ISNATLIST(x₁)) = x₁
POL(LENGTH(x₁)) = x₁
POL(TAKE(x₁, x₂)) = x₁ + x₂
POL(U11(x₁, x₂)) = x₂
POL(U11¹(x₁, x₂)) = x₂
POL(U21(x₁)) = 1 + x₁
POL(U31(x₁, x₂, x₃, x₄)) = 1 + x₂ + x₃ + x₄
POL(U31¹(x₁, x₂, x₃, x₄)) = x₂ + x₃ + x₄
POL(a(x₁)) = x₁
POL(and(x₁, x₂)) = x₁ + x₂
POL(andInact(x₁, x₂)) = x₁ + x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(consInact(x₁, x₂)) = x₁ + x₂
POL(isNat(x₁)) = x₁
POL(isNatIList(x₁)) = x₁
POL(isNatIListInact(x₁)) = x₁
POL(isNatInact(x₁)) = x₁
POL(isNatList(x₁)) = x₁
POL(isNatListInact(x₁)) = x₁
POL(length(x₁)) = x₁
POL(lengthInact(x₁)) = x₁
POL(nil) = 0
POL(nilInact) = 0
POL(s(x₁)) = x₁
POL(sInact(x₁)) = x₁
POL(take(x₁, x₂)) = 1 + x₁ + x₂
POL(takeInact(x₁, x₂)) = 1 + x₁ + x₂
POL(tt) = 0
POL(zeros) = 0
POL(zerosInact) = 0

The following usable rules [17] were oriented:

length(nil) → 0
a(consInact(x1, x2)) → cons(a(x1), x2)
isNatList(nilInact) → tt
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
isNatList(x1) → isNatListInact(x1)
a(takeInact(x1, x2)) → take(a(x1), a(x2))
length(x1) → lengthInact(x1)
U21(tt) → nil
a(lengthInact(x1)) → length(a(x1))
nil → nilInact
take(0, IL) → U21(isNatIList(IL))
isNat(0Inact) → tt
isNat(x1) → isNatInact(x1)
and(x1, x2) → andInact(x1, x2)
a(0Inact) → 0
a(zerosInact) → zeros
0 → 0Inact
take(x1, x2) → takeInact(x1, x2)
a(x) → x
s(x1) → sInact(x1)
zeros → cons(0, zerosInact)
a(sInact(x1)) → s(a(x1))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(nilInact) → nil
isNatIList(x1) → isNatIListInact(x1)
isNatIList(zerosInact) → tt
U11(tt, L) → s(length(a(L)))
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
zeros → zerosInact
cons(x1, x2) → consInact(x1, x2)
a(isNatInact(x1)) → isNat(x1)
and(tt, X) → a(X)
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
a(isNatIListInact(x1)) → isNatIList(x1)
a(isNatListInact(x1)) → isNatList(x1)
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatIList(V) → isNatList(a(V))
isNat(lengthInact(V1)) → isNatList(a(V1))
a(andInact(x1, x2)) → and(a(x1), x2)

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

  ↳ Complete Giesl Middeldorp-Transformation

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

TAKE(s(M), cons(N, IL)) → U31¹(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
A(sInact(x1)) → A(x1)
U31¹(tt, IL, M, N) → A(N)
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
TAKE(s(M), cons(N, IL)) → ISNATILIST(a(IL))
U11¹(tt, L) → LENGTH(a(L))
AND(tt, X) → A(X)
A(lengthInact(x1)) → A(x1)
TAKE(s(M), cons(N, IL)) → A(IL)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
A(consInact(x1, x2)) → A(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
ISNAT(lengthInact(V1)) → A(V1)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
A(andInact(x1, x2)) → A(x1)
U31¹(tt, IL, M, N) → A(M)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
U31¹(tt, IL, M, N) → A(IL)
ISNATILIST(V) → ISNATLIST(a(V))
A(lengthInact(x1)) → LENGTH(a(x1))
TAKE(0, IL) → ISNATILIST(IL)
TAKE(s(M), cons(N, IL)) → AND(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N)))
ISNATILIST(V) → A(V)
A(andInact(x1, x2)) → AND(a(x1), x2)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(a(x1), x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(a(x1))
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(a(x1))
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(a(x1), x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 8 less nodes.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
A(sInact(x1)) → A(x1)
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
U11¹(tt, L) → LENGTH(a(L))
AND(tt, X) → A(X)
A(lengthInact(x1)) → A(x1)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
A(consInact(x1, x2)) → A(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNAT(lengthInact(V1)) → A(V1)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
A(andInact(x1, x2)) → A(x1)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
ISNATILIST(V) → ISNATLIST(a(V))
A(lengthInact(x1)) → LENGTH(a(x1))
ISNATILIST(V) → A(V)
A(andInact(x1, x2)) → AND(a(x1), x2)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(a(x1), x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(a(x1))
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(a(x1))
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(a(x1), x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

A(lengthInact(x1)) → A(x1)
ISNAT(lengthInact(V1)) → A(V1)
ISNAT(lengthInact(V1)) → ISNATLIST(a(V1))
A(lengthInact(x1)) → LENGTH(a(x1))

The remaining pairs can at least be oriented weakly.

LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
ISNAT(sInact(V1)) → ISNAT(a(V1))
A(sInact(x1)) → A(x1)
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
U11¹(tt, L) → LENGTH(a(L))
AND(tt, X) → A(X)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
A(consInact(x1, x2)) → A(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
A(andInact(x1, x2)) → A(x1)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
ISNATILIST(V) → ISNATLIST(a(V))
ISNATILIST(V) → A(V)
A(andInact(x1, x2)) → AND(a(x1), x2)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(0Inact) = 0
POL(A(x₁)) = x₁
POL(AND(x₁, x₂)) = x₂
POL(ISNAT(x₁)) = x₁
POL(ISNATILIST(x₁)) = x₁
POL(ISNATLIST(x₁)) = x₁
POL(LENGTH(x₁)) = x₁
POL(U11(x₁, x₂)) = 1 + x₂
POL(U11¹(x₁, x₂)) = x₂
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = x₂ + x₃ + x₄
POL(a(x₁)) = x₁
POL(and(x₁, x₂)) = x₁ + x₂
POL(andInact(x₁, x₂)) = x₁ + x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(consInact(x₁, x₂)) = x₁ + x₂
POL(isNat(x₁)) = x₁
POL(isNatIList(x₁)) = x₁
POL(isNatIListInact(x₁)) = x₁
POL(isNatInact(x₁)) = x₁
POL(isNatList(x₁)) = x₁
POL(isNatListInact(x₁)) = x₁
POL(length(x₁)) = 1 + x₁
POL(lengthInact(x₁)) = 1 + x₁
POL(nil) = 0
POL(nilInact) = 0
POL(s(x₁)) = x₁
POL(sInact(x₁)) = x₁
POL(take(x₁, x₂)) = x₁ + x₂
POL(takeInact(x₁, x₂)) = x₁ + x₂
POL(tt) = 0
POL(zeros) = 0
POL(zerosInact) = 0

The following usable rules [17] were oriented:

length(nil) → 0
a(consInact(x1, x2)) → cons(a(x1), x2)
isNatList(nilInact) → tt
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
isNatList(x1) → isNatListInact(x1)
a(takeInact(x1, x2)) → take(a(x1), a(x2))
length(x1) → lengthInact(x1)
U21(tt) → nil
a(lengthInact(x1)) → length(a(x1))
nil → nilInact
take(0, IL) → U21(isNatIList(IL))
isNat(0Inact) → tt
isNat(x1) → isNatInact(x1)
and(x1, x2) → andInact(x1, x2)
a(0Inact) → 0
a(zerosInact) → zeros
0 → 0Inact
take(x1, x2) → takeInact(x1, x2)
a(x) → x
s(x1) → sInact(x1)
zeros → cons(0, zerosInact)
a(sInact(x1)) → s(a(x1))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(nilInact) → nil
isNatIList(x1) → isNatIListInact(x1)
isNatIList(zerosInact) → tt
U11(tt, L) → s(length(a(L)))
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
zeros → zerosInact
cons(x1, x2) → consInact(x1, x2)
a(isNatInact(x1)) → isNat(x1)
and(tt, X) → a(X)
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
a(isNatIListInact(x1)) → isNatIList(x1)
a(isNatListInact(x1)) → isNatList(x1)
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatIList(V) → isNatList(a(V))
isNat(lengthInact(V1)) → isNatList(a(V1))
a(andInact(x1, x2)) → and(a(x1), x2)

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

  ↳ Complete Giesl Middeldorp-Transformation

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

LENGTH(cons(N, L)) → AND(isNatList(a(L)), isNatInact(N))
ISNAT(sInact(V1)) → ISNAT(a(V1))
LENGTH(cons(N, L)) → ISNATLIST(a(L))
A(sInact(x1)) → A(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
U11¹(tt, L) → A(L)
U11¹(tt, L) → LENGTH(a(L))
AND(tt, X) → A(X)
ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
LENGTH(cons(N, L)) → A(L)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(isNatIListInact(x1)) → ISNATILIST(x1)
A(consInact(x1, x2)) → A(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
A(andInact(x1, x2)) → A(x1)
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))
ISNATILIST(V) → ISNATLIST(a(V))
ISNATILIST(V) → A(V)
A(andInact(x1, x2)) → AND(a(x1), x2)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(a(x1), x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(a(x1))
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(a(x1))
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(a(x1), x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 2 SCCs with 4 less nodes.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                                ↳ QDPOrderProof

                              ↳ QDP

  ↳ Complete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
ISNATILIST(consInact(V1, V2)) → A(V2)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(consInact(x1, x2)) → A(x1)
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(sInact(V1)) → ISNAT(a(V1))
A(andInact(x1, x2)) → A(x1)
A(sInact(x1)) → A(x1)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATILIST(V) → ISNATLIST(a(V))
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
ISNATILIST(consInact(V1, V2)) → A(V1)
ISNATILIST(V) → A(V)
A(andInact(x1, x2)) → AND(a(x1), x2)
AND(tt, X) → A(X)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(a(x1), x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(a(x1))
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(a(x1))
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(a(x1), x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

ISNATILIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATILIST(V) → ISNATLIST(a(V))
ISNATILIST(consInact(V1, V2)) → A(V1)
ISNATILIST(V) → A(V)

The remaining pairs can at least be oriented weakly.

ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(consInact(x1, x2)) → A(x1)
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(sInact(V1)) → ISNAT(a(V1))
A(andInact(x1, x2)) → A(x1)
A(sInact(x1)) → A(x1)
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
A(andInact(x1, x2)) → AND(a(x1), x2)
AND(tt, X) → A(X)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(0Inact) = 0
POL(A(x₁)) = x₁
POL(AND(x₁, x₂)) = x₂
POL(ISNAT(x₁)) = x₁
POL(ISNATILIST(x₁)) = 1 + x₁
POL(ISNATLIST(x₁)) = x₁
POL(U11(x₁, x₂)) = x₂
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 1 + x₂ + x₃ + x₄
POL(a(x₁)) = x₁
POL(and(x₁, x₂)) = x₁ + x₂
POL(andInact(x₁, x₂)) = x₁ + x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(consInact(x₁, x₂)) = x₁ + x₂
POL(isNat(x₁)) = x₁
POL(isNatIList(x₁)) = 1 + x₁
POL(isNatIListInact(x₁)) = 1 + x₁
POL(isNatInact(x₁)) = x₁
POL(isNatList(x₁)) = x₁
POL(isNatListInact(x₁)) = x₁
POL(length(x₁)) = x₁
POL(lengthInact(x₁)) = x₁
POL(nil) = 0
POL(nilInact) = 0
POL(s(x₁)) = x₁
POL(sInact(x₁)) = x₁
POL(take(x₁, x₂)) = 1 + x₁ + x₂
POL(takeInact(x₁, x₂)) = 1 + x₁ + x₂
POL(tt) = 0
POL(zeros) = 0
POL(zerosInact) = 0

The following usable rules [17] were oriented:

length(nil) → 0
a(consInact(x1, x2)) → cons(a(x1), x2)
isNatList(nilInact) → tt
isNatList(x1) → isNatListInact(x1)
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
a(takeInact(x1, x2)) → take(a(x1), a(x2))
length(x1) → lengthInact(x1)
U21(tt) → nil
a(lengthInact(x1)) → length(a(x1))
nil → nilInact
take(0, IL) → U21(isNatIList(IL))
isNat(0Inact) → tt
isNat(x1) → isNatInact(x1)
a(0Inact) → 0
and(x1, x2) → andInact(x1, x2)
a(zerosInact) → zeros
0 → 0Inact
take(x1, x2) → takeInact(x1, x2)
a(x) → x
s(x1) → sInact(x1)
zeros → cons(0, zerosInact)
a(sInact(x1)) → s(a(x1))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(nilInact) → nil
isNatIList(x1) → isNatIListInact(x1)
isNatIList(zerosInact) → tt
U11(tt, L) → s(length(a(L)))
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
zeros → zerosInact
a(isNatInact(x1)) → isNat(x1)
and(tt, X) → a(X)
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
a(isNatIListInact(x1)) → isNatIList(x1)
a(isNatListInact(x1)) → isNatList(x1)
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatIList(V) → isNatList(a(V))
isNat(lengthInact(V1)) → isNatList(a(V1))
a(andInact(x1, x2)) → and(a(x1), x2)
cons(x1, x2) → consInact(x1, x2)

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                              ↳ QDP

  ↳ Complete Giesl Middeldorp-Transformation

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

ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
A(isNatInact(x1)) → ISNAT(x1)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(consInact(x1, x2)) → A(x1)
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(sInact(V1)) → ISNAT(a(V1))
A(andInact(x1, x2)) → A(x1)
A(sInact(x1)) → A(x1)
A(isNatListInact(x1)) → ISNATLIST(x1)
ISNATLIST(consInact(V1, V2)) → A(V1)
A(andInact(x1, x2)) → AND(a(x1), x2)
AND(tt, X) → A(X)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(a(x1), x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(a(x1))
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(a(x1))
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(a(x1), x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

ISNATLIST(consInact(V1, V2)) → ISNAT(a(V1))
ISNATLIST(consInact(V1, V2)) → A(V2)
ISNATLIST(consInact(V1, V2)) → A(V1)

The remaining pairs can at least be oriented weakly.

A(isNatInact(x1)) → ISNAT(x1)
ISNAT(sInact(V1)) → A(V1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
A(consInact(x1, x2)) → A(x1)
A(isNatIListInact(x1)) → ISNATILIST(x1)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(sInact(V1)) → ISNAT(a(V1))
A(andInact(x1, x2)) → A(x1)
A(sInact(x1)) → A(x1)
A(isNatListInact(x1)) → ISNATLIST(x1)
A(andInact(x1, x2)) → AND(a(x1), x2)
AND(tt, X) → A(X)

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(0Inact) = 0
POL(A(x₁)) = x₁
POL(AND(x₁, x₂)) = x₂
POL(ISNAT(x₁)) = x₁
POL(ISNATILIST(x₁)) = 1 + x₁
POL(ISNATLIST(x₁)) = 1 + x₁
POL(U11(x₁, x₂)) = 1 + x₂
POL(U21(x₁)) = 1
POL(U31(x₁, x₂, x₃, x₄)) = 1 + x₂ + x₃ + x₄
POL(a(x₁)) = x₁
POL(and(x₁, x₂)) = x₁ + x₂
POL(andInact(x₁, x₂)) = x₁ + x₂
POL(cons(x₁, x₂)) = x₁ + x₂
POL(consInact(x₁, x₂)) = x₁ + x₂
POL(isNat(x₁)) = x₁
POL(isNatIList(x₁)) = 1 + x₁
POL(isNatIListInact(x₁)) = 1 + x₁
POL(isNatInact(x₁)) = x₁
POL(isNatList(x₁)) = 1 + x₁
POL(isNatListInact(x₁)) = 1 + x₁
POL(length(x₁)) = 1 + x₁
POL(lengthInact(x₁)) = 1 + x₁
POL(nil) = 1
POL(nilInact) = 1
POL(s(x₁)) = x₁
POL(sInact(x₁)) = x₁
POL(take(x₁, x₂)) = 1 + x₁ + x₂
POL(takeInact(x₁, x₂)) = 1 + x₁ + x₂
POL(tt) = 0
POL(zeros) = 0
POL(zerosInact) = 0

The following usable rules [17] were oriented:

length(nil) → 0
a(consInact(x1, x2)) → cons(a(x1), x2)
isNatList(nilInact) → tt
isNatList(x1) → isNatListInact(x1)
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
a(takeInact(x1, x2)) → take(a(x1), a(x2))
length(x1) → lengthInact(x1)
U21(tt) → nil
a(lengthInact(x1)) → length(a(x1))
nil → nilInact
take(0, IL) → U21(isNatIList(IL))
isNat(0Inact) → tt
isNat(x1) → isNatInact(x1)
a(0Inact) → 0
and(x1, x2) → andInact(x1, x2)
a(zerosInact) → zeros
0 → 0Inact
take(x1, x2) → takeInact(x1, x2)
a(x) → x
s(x1) → sInact(x1)
zeros → cons(0, zerosInact)
a(sInact(x1)) → s(a(x1))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(nilInact) → nil
isNatIList(x1) → isNatIListInact(x1)
isNatIList(zerosInact) → tt
U11(tt, L) → s(length(a(L)))
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
zeros → zerosInact
a(isNatInact(x1)) → isNat(x1)
and(tt, X) → a(X)
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
a(isNatIListInact(x1)) → isNatIList(x1)
a(isNatListInact(x1)) → isNatList(x1)
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatIList(V) → isNatList(a(V))
isNat(lengthInact(V1)) → isNatList(a(V1))
a(andInact(x1, x2)) → and(a(x1), x2)
cons(x1, x2) → consInact(x1, x2)

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                              ↳ QDP

  ↳ Complete Giesl Middeldorp-Transformation

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

A(isNatListInact(x1)) → ISNATLIST(x1)
A(isNatInact(x1)) → ISNAT(x1)
ISNATLIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatListInact(a(V2)))
ISNAT(sInact(V1)) → A(V1)
A(isNatIListInact(x1)) → ISNATILIST(x1)
A(consInact(x1, x2)) → A(x1)
ISNATILIST(consInact(V1, V2)) → AND(isNat(a(V1)), isNatIListInact(a(V2)))
ISNAT(sInact(V1)) → ISNAT(a(V1))
A(andInact(x1, x2)) → A(x1)
A(andInact(x1, x2)) → AND(a(x1), x2)
AND(tt, X) → A(X)
A(sInact(x1)) → A(x1)

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(a(x1), x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(a(x1))
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(a(x1))
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(a(x1), x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

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

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ QDP

              ↳ QDPOrderProof

                ↳ QDP

                  ↳ DependencyGraphProof

                    ↳ QDP

                      ↳ QDPOrderProof

                        ↳ QDP

                          ↳ DependencyGraphProof

                            ↳ AND

                              ↳ QDP

                              ↳ QDP

  ↳ Complete Giesl Middeldorp-Transformation

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

U11¹(tt, L) → LENGTH(a(L))
LENGTH(cons(N, L)) → U11¹(and(isNatList(a(L)), isNatInact(N)), a(L))

The TRS R consists of the following rules:

zeros → cons(0, zerosInact)
U11(tt, L) → s(length(a(L)))
U21(tt) → nil
U31(tt, IL, M, N) → cons(a(N), takeInact(a(M), a(IL)))
and(tt, X) → a(X)
isNat(0Inact) → tt
isNat(lengthInact(V1)) → isNatList(a(V1))
isNat(sInact(V1)) → isNat(a(V1))
isNatIList(V) → isNatList(a(V))
isNatIList(zerosInact) → tt
isNatIList(consInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
isNatList(nilInact) → tt
isNatList(consInact(V1, V2)) → and(isNat(a(V1)), isNatListInact(a(V2)))
isNatList(takeInact(V1, V2)) → and(isNat(a(V1)), isNatIListInact(a(V2)))
length(nil) → 0
length(cons(N, L)) → U11(and(isNatList(a(L)), isNatInact(N)), a(L))
take(0, IL) → U21(isNatIList(IL))
take(s(M), cons(N, IL)) → U31(and(isNatIList(a(IL)), andInact(isNatInact(M), isNatInact(N))), a(IL), M, N)
a(x) → x
isNat(x1) → isNatInact(x1)
a(isNatInact(x1)) → isNat(x1)
and(x1, x2) → andInact(x1, x2)
a(andInact(x1, x2)) → and(a(x1), x2)
length(x1) → lengthInact(x1)
a(lengthInact(x1)) → length(a(x1))
zeros → zerosInact
a(zerosInact) → zeros
s(x1) → sInact(x1)
a(sInact(x1)) → s(a(x1))
0 → 0Inact
a(0Inact) → 0
isNatIList(x1) → isNatIListInact(x1)
a(isNatIListInact(x1)) → isNatIList(x1)
nil → nilInact
a(nilInact) → nil
isNatList(x1) → isNatListInact(x1)
a(isNatListInact(x1)) → isNatList(x1)
cons(x1, x2) → consInact(x1, x2)
a(consInact(x1, x2)) → cons(a(x1), x2)
take(x1, x2) → takeInact(x1, x2)
a(takeInact(x1, x2)) → take(a(x1), a(x2))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We applied the Complete Giesl Middeldorp [11] to transform the context-sensitive TRS to an usual TRS.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

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

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

ACTIVE(isNatList(take(V1, V2))) → ISNAT(V1)
ACTIVE(U31(x1, x2, x3, x4)) → ACTIVE(x1)
ACTIVE(length(cons(N, L))) → U11¹(and(isNatList(L), isNat(N)), L)
PROPER(isNatIList(x1)) → ISNATILIST(proper(x1))
ACTIVE(length(cons(N, L))) → AND(isNatList(L), isNat(N))
S(mark(x1)) → S(x1)
U31¹(mark(x1), x2, x3, x4) → U31¹(x1, x2, x3, x4)
PROPER(take(x1, x2)) → PROPER(x2)
ACTIVE(take(s(M), cons(N, IL))) → AND(isNatIList(IL), and(isNat(M), isNat(N)))
PROPER(U11(x1, x2)) → U11¹(proper(x1), proper(x2))
PROPER(U31(x1, x2, x3, x4)) → PROPER(x3)
TOP(mark(x)) → TOP(proper(x))
PROPER(U31(x1, x2, x3, x4)) → PROPER(x1)
TAKE(ok(x1), ok(x2)) → TAKE(x1, x2)
PROPER(length(x1)) → LENGTH(proper(x1))
PROPER(isNatList(x1)) → PROPER(x1)
PROPER(U21(x1)) → PROPER(x1)
ACTIVE(length(cons(N, L))) → ISNAT(N)
ACTIVE(U11(x1, x2)) → ACTIVE(x1)
PROPER(s(x1)) → PROPER(x1)
ACTIVE(take(s(M), cons(N, IL))) → ISNATILIST(IL)
ACTIVE(take(x1, x2)) → ACTIVE(x1)
ACTIVE(take(x1, x2)) → TAKE(active(x1), x2)
PROPER(U11(x1, x2)) → PROPER(x2)
PROPER(take(x1, x2)) → TAKE(proper(x1), proper(x2))
AND(ok(x1), ok(x2)) → AND(x1, x2)
ACTIVE(isNatList(cons(V1, V2))) → ISNAT(V1)
ACTIVE(zeros) → CONS(0, zeros)
PROPER(isNat(x1)) → PROPER(x1)
LENGTH(mark(x1)) → LENGTH(x1)
ACTIVE(U21(x1)) → ACTIVE(x1)
ACTIVE(s(x1)) → ACTIVE(x1)
ACTIVE(isNatList(take(V1, V2))) → AND(isNat(V1), isNatIList(V2))
TAKE(mark(x1), x2) → TAKE(x1, x2)
ACTIVE(cons(x1, x2)) → CONS(active(x1), x2)
ACTIVE(U11(tt, L)) → S(length(L))
ACTIVE(isNatIList(cons(V1, V2))) → ISNATILIST(V2)
ACTIVE(take(x1, x2)) → TAKE(x1, active(x2))
PROPER(U11(x1, x2)) → PROPER(x1)
ACTIVE(isNatList(cons(V1, V2))) → AND(isNat(V1), isNatList(V2))
ISNAT(ok(x1)) → ISNAT(x1)
TOP(ok(x)) → TOP(active(x))
PROPER(cons(x1, x2)) → PROPER(x2)
ACTIVE(U11(tt, L)) → LENGTH(L)
ACTIVE(U11(x1, x2)) → U11¹(active(x1), x2)
ACTIVE(isNatList(take(V1, V2))) → ISNATILIST(V2)
TAKE(x1, mark(x2)) → TAKE(x1, x2)
LENGTH(ok(x1)) → LENGTH(x1)
PROPER(and(x1, x2)) → PROPER(x1)
PROPER(length(x1)) → PROPER(x1)
ACTIVE(take(s(M), cons(N, IL))) → U31¹(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N)
ACTIVE(take(s(M), cons(N, IL))) → ISNAT(M)
PROPER(isNat(x1)) → ISNAT(proper(x1))
ACTIVE(take(0, IL)) → U21¹(isNatIList(IL))
PROPER(and(x1, x2)) → AND(proper(x1), proper(x2))
ACTIVE(take(s(M), cons(N, IL))) → ISNAT(N)
ACTIVE(isNat(length(V1))) → ISNATLIST(V1)
U21¹(mark(x1)) → U21¹(x1)
PROPER(isNatIList(x1)) → PROPER(x1)
ACTIVE(take(s(M), cons(N, IL))) → AND(isNat(M), isNat(N))
ACTIVE(and(x1, x2)) → ACTIVE(x1)
ACTIVE(U31(tt, IL, M, N)) → CONS(N, take(M, IL))
ACTIVE(isNatList(cons(V1, V2))) → ISNATLIST(V2)
PROPER(cons(x1, x2)) → PROPER(x1)
ACTIVE(isNatIList(cons(V1, V2))) → AND(isNat(V1), isNatIList(V2))
TOP(ok(x)) → ACTIVE(x)
ACTIVE(isNatIList(V)) → ISNATLIST(V)
PROPER(take(x1, x2)) → PROPER(x1)
U11¹(mark(x1), x2) → U11¹(x1, x2)
ACTIVE(s(x1)) → S(active(x1))
ACTIVE(U31(x1, x2, x3, x4)) → U31¹(active(x1), x2, x3, x4)
ACTIVE(isNatIList(cons(V1, V2))) → ISNAT(V1)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x2)
AND(mark(x1), x2) → AND(x1, x2)
TOP(mark(x)) → PROPER(x)
ACTIVE(isNat(s(V1))) → ISNAT(V1)
U21¹(ok(x1)) → U21¹(x1)
ISNATILIST(ok(x1)) → ISNATILIST(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x2)
ISNATLIST(ok(x1)) → ISNATLIST(x1)
PROPER(s(x1)) → S(proper(x1))
PROPER(U31(x1, x2, x3, x4)) → U31¹(proper(x1), proper(x2), proper(x3), proper(x4))
S(ok(x1)) → S(x1)
ACTIVE(U21(x1)) → U21¹(active(x1))
CONS(mark(x1), x2) → CONS(x1, x2)
PROPER(isNatList(x1)) → ISNATLIST(proper(x1))
ACTIVE(length(x1)) → ACTIVE(x1)
ACTIVE(cons(x1, x2)) → ACTIVE(x1)
PROPER(U21(x1)) → U21¹(proper(x1))
ACTIVE(length(x1)) → LENGTH(active(x1))
ACTIVE(take(0, IL)) → ISNATILIST(IL)
ACTIVE(length(cons(N, L))) → ISNATLIST(L)
U11¹(ok(x1), ok(x2)) → U11¹(x1, x2)
U31¹(ok(x1), ok(x2), ok(x3), ok(x4)) → U31¹(x1, x2, x3, x4)
PROPER(cons(x1, x2)) → CONS(proper(x1), proper(x2))
CONS(ok(x1), ok(x2)) → CONS(x1, x2)
PROPER(and(x1, x2)) → PROPER(x2)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x4)
ACTIVE(and(x1, x2)) → AND(active(x1), x2)
ACTIVE(U31(tt, IL, M, N)) → TAKE(M, IL)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

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

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

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

ACTIVE(isNatList(take(V1, V2))) → ISNAT(V1)
ACTIVE(U31(x1, x2, x3, x4)) → ACTIVE(x1)
ACTIVE(length(cons(N, L))) → U11¹(and(isNatList(L), isNat(N)), L)
PROPER(isNatIList(x1)) → ISNATILIST(proper(x1))
ACTIVE(length(cons(N, L))) → AND(isNatList(L), isNat(N))
S(mark(x1)) → S(x1)
U31¹(mark(x1), x2, x3, x4) → U31¹(x1, x2, x3, x4)
PROPER(take(x1, x2)) → PROPER(x2)
ACTIVE(take(s(M), cons(N, IL))) → AND(isNatIList(IL), and(isNat(M), isNat(N)))
PROPER(U11(x1, x2)) → U11¹(proper(x1), proper(x2))
PROPER(U31(x1, x2, x3, x4)) → PROPER(x3)
TOP(mark(x)) → TOP(proper(x))
PROPER(U31(x1, x2, x3, x4)) → PROPER(x1)
TAKE(ok(x1), ok(x2)) → TAKE(x1, x2)
PROPER(length(x1)) → LENGTH(proper(x1))
PROPER(isNatList(x1)) → PROPER(x1)
PROPER(U21(x1)) → PROPER(x1)
ACTIVE(length(cons(N, L))) → ISNAT(N)
ACTIVE(U11(x1, x2)) → ACTIVE(x1)
PROPER(s(x1)) → PROPER(x1)
ACTIVE(take(s(M), cons(N, IL))) → ISNATILIST(IL)
ACTIVE(take(x1, x2)) → ACTIVE(x1)
ACTIVE(take(x1, x2)) → TAKE(active(x1), x2)
PROPER(U11(x1, x2)) → PROPER(x2)
PROPER(take(x1, x2)) → TAKE(proper(x1), proper(x2))
AND(ok(x1), ok(x2)) → AND(x1, x2)
ACTIVE(isNatList(cons(V1, V2))) → ISNAT(V1)
ACTIVE(zeros) → CONS(0, zeros)
PROPER(isNat(x1)) → PROPER(x1)
LENGTH(mark(x1)) → LENGTH(x1)
ACTIVE(U21(x1)) → ACTIVE(x1)
ACTIVE(s(x1)) → ACTIVE(x1)
ACTIVE(isNatList(take(V1, V2))) → AND(isNat(V1), isNatIList(V2))
TAKE(mark(x1), x2) → TAKE(x1, x2)
ACTIVE(cons(x1, x2)) → CONS(active(x1), x2)
ACTIVE(U11(tt, L)) → S(length(L))
ACTIVE(isNatIList(cons(V1, V2))) → ISNATILIST(V2)
ACTIVE(take(x1, x2)) → TAKE(x1, active(x2))
PROPER(U11(x1, x2)) → PROPER(x1)
ACTIVE(isNatList(cons(V1, V2))) → AND(isNat(V1), isNatList(V2))
ISNAT(ok(x1)) → ISNAT(x1)
TOP(ok(x)) → TOP(active(x))
PROPER(cons(x1, x2)) → PROPER(x2)
ACTIVE(U11(tt, L)) → LENGTH(L)
ACTIVE(U11(x1, x2)) → U11¹(active(x1), x2)
ACTIVE(isNatList(take(V1, V2))) → ISNATILIST(V2)
TAKE(x1, mark(x2)) → TAKE(x1, x2)
LENGTH(ok(x1)) → LENGTH(x1)
PROPER(and(x1, x2)) → PROPER(x1)
PROPER(length(x1)) → PROPER(x1)
ACTIVE(take(s(M), cons(N, IL))) → U31¹(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N)
ACTIVE(take(s(M), cons(N, IL))) → ISNAT(M)
PROPER(isNat(x1)) → ISNAT(proper(x1))
ACTIVE(take(0, IL)) → U21¹(isNatIList(IL))
PROPER(and(x1, x2)) → AND(proper(x1), proper(x2))
ACTIVE(take(s(M), cons(N, IL))) → ISNAT(N)
ACTIVE(isNat(length(V1))) → ISNATLIST(V1)
U21¹(mark(x1)) → U21¹(x1)
PROPER(isNatIList(x1)) → PROPER(x1)
ACTIVE(take(s(M), cons(N, IL))) → AND(isNat(M), isNat(N))
ACTIVE(and(x1, x2)) → ACTIVE(x1)
ACTIVE(U31(tt, IL, M, N)) → CONS(N, take(M, IL))
ACTIVE(isNatList(cons(V1, V2))) → ISNATLIST(V2)
PROPER(cons(x1, x2)) → PROPER(x1)
ACTIVE(isNatIList(cons(V1, V2))) → AND(isNat(V1), isNatIList(V2))
TOP(ok(x)) → ACTIVE(x)
ACTIVE(isNatIList(V)) → ISNATLIST(V)
PROPER(take(x1, x2)) → PROPER(x1)
U11¹(mark(x1), x2) → U11¹(x1, x2)
ACTIVE(s(x1)) → S(active(x1))
ACTIVE(U31(x1, x2, x3, x4)) → U31¹(active(x1), x2, x3, x4)
ACTIVE(isNatIList(cons(V1, V2))) → ISNAT(V1)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x2)
AND(mark(x1), x2) → AND(x1, x2)
TOP(mark(x)) → PROPER(x)
ACTIVE(isNat(s(V1))) → ISNAT(V1)
U21¹(ok(x1)) → U21¹(x1)
ISNATILIST(ok(x1)) → ISNATILIST(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x2)
ISNATLIST(ok(x1)) → ISNATLIST(x1)
PROPER(s(x1)) → S(proper(x1))
PROPER(U31(x1, x2, x3, x4)) → U31¹(proper(x1), proper(x2), proper(x3), proper(x4))
S(ok(x1)) → S(x1)
ACTIVE(U21(x1)) → U21¹(active(x1))
CONS(mark(x1), x2) → CONS(x1, x2)
PROPER(isNatList(x1)) → ISNATLIST(proper(x1))
ACTIVE(length(x1)) → ACTIVE(x1)
ACTIVE(cons(x1, x2)) → ACTIVE(x1)
PROPER(U21(x1)) → U21¹(proper(x1))
ACTIVE(length(x1)) → LENGTH(active(x1))
ACTIVE(take(0, IL)) → ISNATILIST(IL)
ACTIVE(length(cons(N, L))) → ISNATLIST(L)
U11¹(ok(x1), ok(x2)) → U11¹(x1, x2)
U31¹(ok(x1), ok(x2), ok(x3), ok(x4)) → U31¹(x1, x2, x3, x4)
PROPER(cons(x1, x2)) → CONS(proper(x1), proper(x2))
CONS(ok(x1), ok(x2)) → CONS(x1, x2)
PROPER(and(x1, x2)) → PROPER(x2)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x4)
ACTIVE(and(x1, x2)) → AND(active(x1), x2)
ACTIVE(U31(tt, IL, M, N)) → TAKE(M, IL)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 14 SCCs with 51 less nodes.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

ISNATILIST(ok(x1)) → ISNATILIST(x1)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

ISNATILIST(ok(x1)) → ISNATILIST(x1)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

ISNATILIST(ok(x1)) → ISNATILIST(x1)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

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

ISNATILIST(ok(x1)) → ISNATILIST(x1)
The graph contains the following edges 1 > 1

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

ISNATLIST(ok(x1)) → ISNATLIST(x1)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

ISNATLIST(ok(x1)) → ISNATLIST(x1)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

ISNATLIST(ok(x1)) → ISNATLIST(x1)

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

ISNATLIST(ok(x1)) → ISNATLIST(x1)
The graph contains the following edges 1 > 1

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

ISNAT(ok(x1)) → ISNAT(x1)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

ISNAT(ok(x1)) → ISNAT(x1)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

ISNAT(ok(x1)) → ISNAT(x1)

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

ISNAT(ok(x1)) → ISNAT(x1)
The graph contains the following edges 1 > 1

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

AND(ok(x1), ok(x2)) → AND(x1, x2)
AND(mark(x1), x2) → AND(x1, x2)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

AND(ok(x1), ok(x2)) → AND(x1, x2)
AND(mark(x1), x2) → AND(x1, x2)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

AND(ok(x1), ok(x2)) → AND(x1, x2)
AND(mark(x1), x2) → AND(x1, x2)

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

AND(ok(x1), ok(x2)) → AND(x1, x2)
The graph contains the following edges 1 > 1, 2 > 2
AND(mark(x1), x2) → AND(x1, x2)
The graph contains the following edges 1 > 1, 2 >= 2

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

TAKE(mark(x1), x2) → TAKE(x1, x2)
TAKE(x1, mark(x2)) → TAKE(x1, x2)
TAKE(ok(x1), ok(x2)) → TAKE(x1, x2)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

TAKE(mark(x1), x2) → TAKE(x1, x2)
TAKE(x1, mark(x2)) → TAKE(x1, x2)
TAKE(ok(x1), ok(x2)) → TAKE(x1, x2)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

TAKE(mark(x1), x2) → TAKE(x1, x2)
TAKE(x1, mark(x2)) → TAKE(x1, x2)
TAKE(ok(x1), ok(x2)) → TAKE(x1, x2)

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

TAKE(mark(x1), x2) → TAKE(x1, x2)
The graph contains the following edges 1 > 1, 2 >= 2
TAKE(x1, mark(x2)) → TAKE(x1, x2)
The graph contains the following edges 1 >= 1, 2 > 2
TAKE(ok(x1), ok(x2)) → TAKE(x1, x2)
The graph contains the following edges 1 > 1, 2 > 2

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

U31¹(mark(x1), x2, x3, x4) → U31¹(x1, x2, x3, x4)
U31¹(ok(x1), ok(x2), ok(x3), ok(x4)) → U31¹(x1, x2, x3, x4)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

U31¹(mark(x1), x2, x3, x4) → U31¹(x1, x2, x3, x4)
U31¹(ok(x1), ok(x2), ok(x3), ok(x4)) → U31¹(x1, x2, x3, x4)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

U31¹(mark(x1), x2, x3, x4) → U31¹(x1, x2, x3, x4)
U31¹(ok(x1), ok(x2), ok(x3), ok(x4)) → U31¹(x1, x2, x3, x4)

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

U31¹(mark(x1), x2, x3, x4) → U31¹(x1, x2, x3, x4)
The graph contains the following edges 1 > 1, 2 >= 2, 3 >= 3, 4 >= 4
U31¹(ok(x1), ok(x2), ok(x3), ok(x4)) → U31¹(x1, x2, x3, x4)
The graph contains the following edges 1 > 1, 2 > 2, 3 > 3, 4 > 4

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

U21¹(mark(x1)) → U21¹(x1)
U21¹(ok(x1)) → U21¹(x1)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

U21¹(mark(x1)) → U21¹(x1)
U21¹(ok(x1)) → U21¹(x1)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

U21¹(mark(x1)) → U21¹(x1)
U21¹(ok(x1)) → U21¹(x1)

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

U21¹(mark(x1)) → U21¹(x1)
The graph contains the following edges 1 > 1
U21¹(ok(x1)) → U21¹(x1)
The graph contains the following edges 1 > 1

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

LENGTH(mark(x1)) → LENGTH(x1)
LENGTH(ok(x1)) → LENGTH(x1)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

LENGTH(mark(x1)) → LENGTH(x1)
LENGTH(ok(x1)) → LENGTH(x1)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

LENGTH(ok(x1)) → LENGTH(x1)
LENGTH(mark(x1)) → LENGTH(x1)

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

LENGTH(mark(x1)) → LENGTH(x1)
The graph contains the following edges 1 > 1
LENGTH(ok(x1)) → LENGTH(x1)
The graph contains the following edges 1 > 1

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

S(ok(x1)) → S(x1)
S(mark(x1)) → S(x1)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

S(ok(x1)) → S(x1)
S(mark(x1)) → S(x1)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

S(ok(x1)) → S(x1)
S(mark(x1)) → S(x1)

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

S(ok(x1)) → S(x1)
The graph contains the following edges 1 > 1
S(mark(x1)) → S(x1)
The graph contains the following edges 1 > 1

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

U11¹(mark(x1), x2) → U11¹(x1, x2)
U11¹(ok(x1), ok(x2)) → U11¹(x1, x2)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

U11¹(mark(x1), x2) → U11¹(x1, x2)
U11¹(ok(x1), ok(x2)) → U11¹(x1, x2)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

U11¹(mark(x1), x2) → U11¹(x1, x2)
U11¹(ok(x1), ok(x2)) → U11¹(x1, x2)

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

U11¹(mark(x1), x2) → U11¹(x1, x2)
The graph contains the following edges 1 > 1, 2 >= 2
U11¹(ok(x1), ok(x2)) → U11¹(x1, x2)
The graph contains the following edges 1 > 1, 2 > 2

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

CONS(mark(x1), x2) → CONS(x1, x2)
CONS(ok(x1), ok(x2)) → CONS(x1, x2)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

CONS(mark(x1), x2) → CONS(x1, x2)
CONS(ok(x1), ok(x2)) → CONS(x1, x2)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

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

CONS(mark(x1), x2) → CONS(x1, x2)
CONS(ok(x1), ok(x2)) → CONS(x1, x2)

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

CONS(mark(x1), x2) → CONS(x1, x2)
The graph contains the following edges 1 > 1, 2 >= 2
CONS(ok(x1), ok(x2)) → CONS(x1, x2)
The graph contains the following edges 1 > 1, 2 > 2

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

              ↳ QDP

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

PROPER(and(x1, x2)) → PROPER(x1)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x1)
PROPER(length(x1)) → PROPER(x1)
PROPER(cons(x1, x2)) → PROPER(x1)
PROPER(isNat(x1)) → PROPER(x1)
PROPER(isNatList(x1)) → PROPER(x1)
PROPER(U21(x1)) → PROPER(x1)
PROPER(take(x1, x2)) → PROPER(x1)
PROPER(take(x1, x2)) → PROPER(x2)
PROPER(U11(x1, x2)) → PROPER(x1)
PROPER(isNatIList(x1)) → PROPER(x1)
PROPER(s(x1)) → PROPER(x1)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x2)
PROPER(cons(x1, x2)) → PROPER(x2)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x3)
PROPER(and(x1, x2)) → PROPER(x2)
PROPER(U11(x1, x2)) → PROPER(x2)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x4)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

              ↳ QDP

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

PROPER(and(x1, x2)) → PROPER(x1)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x1)
PROPER(length(x1)) → PROPER(x1)
PROPER(cons(x1, x2)) → PROPER(x1)
PROPER(isNat(x1)) → PROPER(x1)
PROPER(isNatList(x1)) → PROPER(x1)
PROPER(U21(x1)) → PROPER(x1)
PROPER(take(x1, x2)) → PROPER(x1)
PROPER(take(x1, x2)) → PROPER(x2)
PROPER(U11(x1, x2)) → PROPER(x1)
PROPER(isNatIList(x1)) → PROPER(x1)
PROPER(s(x1)) → PROPER(x1)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x2)
PROPER(cons(x1, x2)) → PROPER(x2)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x3)
PROPER(and(x1, x2)) → PROPER(x2)
PROPER(U11(x1, x2)) → PROPER(x2)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x4)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
proper(cons(x0, x1))
proper(0)
active(U11(x0, x1))
proper(U11(x0, x1))
proper(tt)
active(s(x0))
proper(s(x0))
active(length(x0))
proper(length(x0))
active(U21(x0))
proper(U21(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
proper(U31(x0, x1, x2, x3))
active(take(x0, x1))
proper(take(x0, x1))
active(and(x0, x1))
proper(and(x0, x1))
proper(isNat(x0))
proper(isNatList(x0))
proper(isNatIList(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

              ↳ QDP

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

PROPER(and(x1, x2)) → PROPER(x1)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x1)
PROPER(length(x1)) → PROPER(x1)
PROPER(cons(x1, x2)) → PROPER(x1)
PROPER(isNat(x1)) → PROPER(x1)
PROPER(isNatList(x1)) → PROPER(x1)
PROPER(U21(x1)) → PROPER(x1)
PROPER(take(x1, x2)) → PROPER(x1)
PROPER(take(x1, x2)) → PROPER(x2)
PROPER(U11(x1, x2)) → PROPER(x1)
PROPER(isNatIList(x1)) → PROPER(x1)
PROPER(s(x1)) → PROPER(x1)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x2)
PROPER(cons(x1, x2)) → PROPER(x2)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x3)
PROPER(and(x1, x2)) → PROPER(x2)
PROPER(U31(x1, x2, x3, x4)) → PROPER(x4)
PROPER(U11(x1, x2)) → PROPER(x2)

R is empty.
The set Q consists of the following terms:

cons(mark(x0), x1)
cons(ok(x0), ok(x1))
U11(mark(x0), x1)
U11(ok(x0), ok(x1))
s(mark(x0))
s(ok(x0))
length(mark(x0))
length(ok(x0))
U21(mark(x0))
U21(ok(x0))
U31(mark(x0), x1, x2, x3)
U31(ok(x0), ok(x1), ok(x2), ok(x3))
take(mark(x0), x1)
take(x0, mark(x1))
take(ok(x0), ok(x1))
and(mark(x0), x1)
and(ok(x0), ok(x1))
isNat(ok(x0))
isNatList(ok(x0))
isNatIList(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

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

PROPER(and(x1, x2)) → PROPER(x1)
The graph contains the following edges 1 > 1
PROPER(U31(x1, x2, x3, x4)) → PROPER(x1)
The graph contains the following edges 1 > 1
PROPER(length(x1)) → PROPER(x1)
The graph contains the following edges 1 > 1
PROPER(cons(x1, x2)) → PROPER(x1)
The graph contains the following edges 1 > 1
PROPER(isNat(x1)) → PROPER(x1)
The graph contains the following edges 1 > 1
PROPER(isNatList(x1)) → PROPER(x1)
The graph contains the following edges 1 > 1
PROPER(U21(x1)) → PROPER(x1)
The graph contains the following edges 1 > 1
PROPER(take(x1, x2)) → PROPER(x1)
The graph contains the following edges 1 > 1
PROPER(take(x1, x2)) → PROPER(x2)
The graph contains the following edges 1 > 1
PROPER(U11(x1, x2)) → PROPER(x1)
The graph contains the following edges 1 > 1
PROPER(isNatIList(x1)) → PROPER(x1)
The graph contains the following edges 1 > 1
PROPER(s(x1)) → PROPER(x1)
The graph contains the following edges 1 > 1
PROPER(U31(x1, x2, x3, x4)) → PROPER(x2)
The graph contains the following edges 1 > 1
PROPER(cons(x1, x2)) → PROPER(x2)
The graph contains the following edges 1 > 1
PROPER(U31(x1, x2, x3, x4)) → PROPER(x3)
The graph contains the following edges 1 > 1
PROPER(and(x1, x2)) → PROPER(x2)
The graph contains the following edges 1 > 1
PROPER(U11(x1, x2)) → PROPER(x2)
The graph contains the following edges 1 > 1
PROPER(U31(x1, x2, x3, x4)) → PROPER(x4)
The graph contains the following edges 1 > 1

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

              ↳ QDP

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

ACTIVE(U31(x1, x2, x3, x4)) → ACTIVE(x1)
ACTIVE(length(x1)) → ACTIVE(x1)
ACTIVE(cons(x1, x2)) → ACTIVE(x1)
ACTIVE(U11(x1, x2)) → ACTIVE(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x2)
ACTIVE(and(x1, x2)) → ACTIVE(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x1)
ACTIVE(U21(x1)) → ACTIVE(x1)
ACTIVE(s(x1)) → ACTIVE(x1)

The TRS R consists of the following rules:

active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

              ↳ QDP

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

ACTIVE(U31(x1, x2, x3, x4)) → ACTIVE(x1)
ACTIVE(length(x1)) → ACTIVE(x1)
ACTIVE(cons(x1, x2)) → ACTIVE(x1)
ACTIVE(U11(x1, x2)) → ACTIVE(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x2)
ACTIVE(and(x1, x2)) → ACTIVE(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x1)
ACTIVE(U21(x1)) → ACTIVE(x1)
ACTIVE(s(x1)) → ACTIVE(x1)

R is empty.
The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
proper(cons(x0, x1))
proper(0)
active(U11(x0, x1))
proper(U11(x0, x1))
proper(tt)
active(s(x0))
proper(s(x0))
active(length(x0))
proper(length(x0))
active(U21(x0))
proper(U21(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
proper(U31(x0, x1, x2, x3))
active(take(x0, x1))
proper(take(x0, x1))
active(and(x0, x1))
proper(and(x0, x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ QDPSizeChangeProof

              ↳ QDP

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

ACTIVE(U31(x1, x2, x3, x4)) → ACTIVE(x1)
ACTIVE(length(x1)) → ACTIVE(x1)
ACTIVE(U11(x1, x2)) → ACTIVE(x1)
ACTIVE(cons(x1, x2)) → ACTIVE(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x2)
ACTIVE(U21(x1)) → ACTIVE(x1)
ACTIVE(take(x1, x2)) → ACTIVE(x1)
ACTIVE(and(x1, x2)) → ACTIVE(x1)
ACTIVE(s(x1)) → ACTIVE(x1)

R is empty.
The set Q consists of the following terms:

cons(mark(x0), x1)
cons(ok(x0), ok(x1))
U11(mark(x0), x1)
U11(ok(x0), ok(x1))
s(mark(x0))
s(ok(x0))
length(mark(x0))
length(ok(x0))
U21(mark(x0))
U21(ok(x0))
U31(mark(x0), x1, x2, x3)
U31(ok(x0), ok(x1), ok(x2), ok(x3))
take(mark(x0), x1)
take(x0, mark(x1))
take(ok(x0), ok(x1))
and(mark(x0), x1)
and(ok(x0), ok(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

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

ACTIVE(U31(x1, x2, x3, x4)) → ACTIVE(x1)
The graph contains the following edges 1 > 1
ACTIVE(length(x1)) → ACTIVE(x1)
The graph contains the following edges 1 > 1
ACTIVE(cons(x1, x2)) → ACTIVE(x1)
The graph contains the following edges 1 > 1
ACTIVE(U11(x1, x2)) → ACTIVE(x1)
The graph contains the following edges 1 > 1
ACTIVE(take(x1, x2)) → ACTIVE(x2)
The graph contains the following edges 1 > 1
ACTIVE(and(x1, x2)) → ACTIVE(x1)
The graph contains the following edges 1 > 1
ACTIVE(take(x1, x2)) → ACTIVE(x1)
The graph contains the following edges 1 > 1
ACTIVE(U21(x1)) → ACTIVE(x1)
The graph contains the following edges 1 > 1
ACTIVE(s(x1)) → ACTIVE(x1)
The graph contains the following edges 1 > 1

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

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(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
proper(zeros) → ok(zeros)
active(cons(x1, x2)) → cons(active(x1), x2)
cons(mark(x1), x2) → mark(cons(x1, x2))
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
proper(0) → ok(0)
active(U11(x1, x2)) → U11(active(x1), x2)
U11(mark(x1), x2) → mark(U11(x1, x2))
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
proper(tt) → ok(tt)
active(s(x1)) → s(active(x1))
s(mark(x1)) → mark(s(x1))
proper(s(x1)) → s(proper(x1))
s(ok(x1)) → ok(s(x1))
active(length(x1)) → length(active(x1))
length(mark(x1)) → mark(length(x1))
proper(length(x1)) → length(proper(x1))
length(ok(x1)) → ok(length(x1))
active(U21(x1)) → U21(active(x1))
U21(mark(x1)) → mark(U21(x1))
proper(U21(x1)) → U21(proper(x1))
U21(ok(x1)) → ok(U21(x1))
proper(nil) → ok(nil)
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
active(take(x1, x2)) → take(active(x1), x2)
take(mark(x1), x2) → mark(take(x1, x2))
active(take(x1, x2)) → take(x1, active(x2))
take(x1, mark(x2)) → mark(take(x1, x2))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
active(and(x1, x2)) → and(active(x1), x2)
and(mark(x1), x2) → mark(and(x1, x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
proper(isNat(x1)) → isNat(proper(x1))
isNat(ok(x1)) → ok(isNat(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
top(mark(x)) → top(proper(x))
top(ok(x)) → top(active(x))

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

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:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(s(x1)) → s(proper(x1))
proper(length(x1)) → length(proper(x1))
proper(U21(x1)) → U21(proper(x1))
proper(nil) → ok(nil)
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(isNat(x1)) → isNat(proper(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
isNat(ok(x1)) → ok(isNat(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
U21(mark(x1)) → mark(U21(x1))
U21(ok(x1)) → ok(U21(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
active(cons(x1, x2)) → cons(active(x1), x2)
active(U11(x1, x2)) → U11(active(x1), x2)
active(s(x1)) → s(active(x1))
active(length(x1)) → length(active(x1))
active(U21(x1)) → U21(active(x1))
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))
active(and(x1, x2)) → and(active(x1), x2)

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))
top(mark(x0))
top(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

top(mark(x0))
top(ok(x0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

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:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(s(x1)) → s(proper(x1))
proper(length(x1)) → length(proper(x1))
proper(U21(x1)) → U21(proper(x1))
proper(nil) → ok(nil)
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(isNat(x1)) → isNat(proper(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
isNat(ok(x1)) → ok(isNat(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
U21(mark(x1)) → mark(U21(x1))
U21(ok(x1)) → ok(U21(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
active(cons(x1, x2)) → cons(active(x1), x2)
active(U11(x1, x2)) → U11(active(x1), x2)
active(s(x1)) → s(active(x1))
active(length(x1)) → length(active(x1))
active(U21(x1)) → U21(active(x1))
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))
active(and(x1, x2)) → and(active(x1), x2)

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule TOP(ok(x)) → TOP(active(x)) at position [0] we obtained the following new rules:

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(ok(U31(tt, x0, x1, x2))) → TOP(mark(cons(x2, take(x1, x0))))
TOP(ok(U21(tt))) → TOP(mark(nil))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatList(nil))) → TOP(mark(tt))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(and(tt, x0))) → TOP(mark(x0))
TOP(ok(take(0, x0))) → TOP(mark(U21(isNatIList(x0))))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(length(nil))) → TOP(mark(0))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(ok(zeros)) → TOP(mark(cons(0, zeros)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(U11(and(isNatList(x1), isNat(x0)), x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(ok(isNatIList(zeros))) → TOP(mark(tt))
TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))
TOP(ok(isNat(0))) → TOP(mark(tt))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

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

TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(U31(tt, x0, x1, x2))) → TOP(mark(cons(x2, take(x1, x0))))
TOP(ok(U21(tt))) → TOP(mark(nil))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatList(nil))) → TOP(mark(tt))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(x)) → TOP(proper(x))
TOP(ok(and(tt, x0))) → TOP(mark(x0))
TOP(ok(take(0, x0))) → TOP(mark(U21(isNatIList(x0))))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(length(nil))) → TOP(mark(0))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(ok(zeros)) → TOP(mark(cons(0, zeros)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(U11(and(isNatList(x1), isNat(x0)), x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(ok(isNatIList(zeros))) → TOP(mark(tt))
TOP(ok(isNat(0))) → TOP(mark(tt))
TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(s(x1)) → s(proper(x1))
proper(length(x1)) → length(proper(x1))
proper(U21(x1)) → U21(proper(x1))
proper(nil) → ok(nil)
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(isNat(x1)) → isNat(proper(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
isNat(ok(x1)) → ok(isNat(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
U21(mark(x1)) → mark(U21(x1))
U21(ok(x1)) → ok(U21(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
active(cons(x1, x2)) → cons(active(x1), x2)
active(U11(x1, x2)) → U11(active(x1), x2)
active(s(x1)) → s(active(x1))
active(length(x1)) → length(active(x1))
active(U21(x1)) → U21(active(x1))
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))
active(and(x1, x2)) → and(active(x1), x2)

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule TOP(mark(x)) → TOP(proper(x)) at position [0] we obtained the following new rules:

TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(mark(zeros)) → TOP(ok(zeros))
TOP(mark(tt)) → TOP(ok(tt))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(nil)) → TOP(ok(nil))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))
TOP(mark(0)) → TOP(ok(0))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

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

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(U31(tt, x0, x1, x2))) → TOP(mark(cons(x2, take(x1, x0))))
TOP(ok(U21(tt))) → TOP(mark(nil))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(mark(zeros)) → TOP(ok(zeros))
TOP(mark(tt)) → TOP(ok(tt))
TOP(ok(isNatList(nil))) → TOP(mark(tt))
TOP(mark(nil)) → TOP(ok(nil))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(take(0, x0))) → TOP(mark(U21(isNatIList(x0))))
TOP(ok(and(tt, x0))) → TOP(mark(x0))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(mark(0)) → TOP(ok(0))
TOP(ok(length(nil))) → TOP(mark(0))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(zeros)) → TOP(mark(cons(0, zeros)))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(U11(and(isNatList(x1), isNat(x0)), x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(ok(isNatIList(zeros))) → TOP(mark(tt))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))
TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))
TOP(ok(isNat(0))) → TOP(mark(tt))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(s(x1)) → s(proper(x1))
proper(length(x1)) → length(proper(x1))
proper(U21(x1)) → U21(proper(x1))
proper(nil) → ok(nil)
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(isNat(x1)) → isNat(proper(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
isNat(ok(x1)) → ok(isNat(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
U21(mark(x1)) → mark(U21(x1))
U21(ok(x1)) → ok(U21(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
active(cons(x1, x2)) → cons(active(x1), x2)
active(U11(x1, x2)) → U11(active(x1), x2)
active(s(x1)) → s(active(x1))
active(length(x1)) → length(active(x1))
active(U21(x1)) → U21(active(x1))
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))
active(and(x1, x2)) → and(active(x1), x2)

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 8 less nodes.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ ForwardInstantiation

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

TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(U31(tt, x0, x1, x2))) → TOP(mark(cons(x2, take(x1, x0))))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(mark(zeros)) → TOP(ok(zeros))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(and(tt, x0))) → TOP(mark(x0))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(take(0, x0))) → TOP(mark(U21(isNatIList(x0))))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(zeros)) → TOP(mark(cons(0, zeros)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(U11(and(isNatList(x1), isNat(x0)), x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))
TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(s(x1)) → s(proper(x1))
proper(length(x1)) → length(proper(x1))
proper(U21(x1)) → U21(proper(x1))
proper(nil) → ok(nil)
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(isNat(x1)) → isNat(proper(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
isNat(ok(x1)) → ok(isNat(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
U21(mark(x1)) → mark(U21(x1))
U21(ok(x1)) → ok(U21(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
active(cons(x1, x2)) → cons(active(x1), x2)
active(U11(x1, x2)) → U11(active(x1), x2)
active(s(x1)) → s(active(x1))
active(length(x1)) → length(active(x1))
active(U21(x1)) → U21(active(x1))
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))
active(and(x1, x2)) → and(active(x1), x2)

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
By forward instantiating [14] the rule TOP(ok(and(tt, x0))) → TOP(mark(x0)) we obtained the following new rules:

TOP(ok(and(tt, U31(y_0, y_1, y_2, y_3)))) → TOP(mark(U31(y_0, y_1, y_2, y_3)))
TOP(ok(and(tt, U11(y_0, y_1)))) → TOP(mark(U11(y_0, y_1)))
TOP(ok(and(tt, s(y_0)))) → TOP(mark(s(y_0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(and(tt, cons(y_0, y_1)))) → TOP(mark(cons(y_0, y_1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(and(tt, length(y_0)))) → TOP(mark(length(y_0)))
TOP(ok(and(tt, take(y_0, y_1)))) → TOP(mark(take(y_0, y_1)))
TOP(ok(and(tt, U21(y_0)))) → TOP(mark(U21(y_0)))
TOP(ok(and(tt, zeros))) → TOP(mark(zeros))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ ForwardInstantiation

                                      ↳ QDP

                                        ↳ QDPOrderProof

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

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(U31(tt, x0, x1, x2))) → TOP(mark(cons(x2, take(x1, x0))))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(mark(zeros)) → TOP(ok(zeros))
TOP(ok(and(tt, U11(y_0, y_1)))) → TOP(mark(U11(y_0, y_1)))
TOP(ok(and(tt, U31(y_0, y_1, y_2, y_3)))) → TOP(mark(U31(y_0, y_1, y_2, y_3)))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(and(tt, length(y_0)))) → TOP(mark(length(y_0)))
TOP(ok(take(0, x0))) → TOP(mark(U21(isNatIList(x0))))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, s(y_0)))) → TOP(mark(s(y_0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, cons(y_0, y_1)))) → TOP(mark(cons(y_0, y_1)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(ok(and(tt, U21(y_0)))) → TOP(mark(U21(y_0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(zeros)) → TOP(mark(cons(0, zeros)))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(and(tt, take(y_0, y_1)))) → TOP(mark(take(y_0, y_1)))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(U11(and(isNatList(x1), isNat(x0)), x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(and(tt, zeros))) → TOP(mark(zeros))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(s(x1)) → s(proper(x1))
proper(length(x1)) → length(proper(x1))
proper(U21(x1)) → U21(proper(x1))
proper(nil) → ok(nil)
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(isNat(x1)) → isNat(proper(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
isNat(ok(x1)) → ok(isNat(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
U21(mark(x1)) → mark(U21(x1))
U21(ok(x1)) → ok(U21(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
active(cons(x1, x2)) → cons(active(x1), x2)
active(U11(x1, x2)) → U11(active(x1), x2)
active(s(x1)) → s(active(x1))
active(length(x1)) → length(active(x1))
active(U21(x1)) → U21(active(x1))
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))
active(and(x1, x2)) → and(active(x1), x2)

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

TOP(ok(and(tt, U11(y_0, y_1)))) → TOP(mark(U11(y_0, y_1)))
TOP(ok(and(tt, U31(y_0, y_1, y_2, y_3)))) → TOP(mark(U31(y_0, y_1, y_2, y_3)))
TOP(ok(and(tt, length(y_0)))) → TOP(mark(length(y_0)))
TOP(ok(and(tt, s(y_0)))) → TOP(mark(s(y_0)))
TOP(ok(and(tt, cons(y_0, y_1)))) → TOP(mark(cons(y_0, y_1)))
TOP(ok(and(tt, U21(y_0)))) → TOP(mark(U21(y_0)))
TOP(ok(zeros)) → TOP(mark(cons(0, zeros)))
TOP(ok(and(tt, take(y_0, y_1)))) → TOP(mark(take(y_0, y_1)))

The remaining pairs can at least be oriented weakly.

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(U31(tt, x0, x1, x2))) → TOP(mark(cons(x2, take(x1, x0))))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(mark(zeros)) → TOP(ok(zeros))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(take(0, x0))) → TOP(mark(U21(isNatIList(x0))))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(U11(and(isNatList(x1), isNat(x0)), x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(and(tt, zeros))) → TOP(mark(zeros))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(TOP(x₁)) = x₁
POL(U11(x₁, x₂)) = 0
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 0
POL(active(x₁)) = 0
POL(and(x₁, x₂)) = 1
POL(cons(x₁, x₂)) = 0
POL(isNat(x₁)) = 1
POL(isNatIList(x₁)) = 1
POL(isNatList(x₁)) = 1
POL(length(x₁)) = 0
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(ok(x₁)) = x₁
POL(proper(x₁)) = 0
POL(s(x₁)) = 0
POL(take(x₁, x₂)) = 0
POL(tt) = 0
POL(zeros) = 1

The following usable rules [17] were oriented:

take(mark(x1), x2) → mark(take(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
isNat(ok(x1)) → ok(isNat(x1))
cons(mark(x1), x2) → mark(cons(x1, x2))
U21(mark(x1)) → mark(U21(x1))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
and(mark(x1), x2) → mark(and(x1, x2))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
U21(ok(x1)) → ok(U21(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
isNatIList(ok(x1)) → ok(isNatIList(x1))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
isNatList(ok(x1)) → ok(isNatList(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
take(x1, mark(x2)) → mark(take(x1, x2))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ ForwardInstantiation

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ DependencyGraphProof

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

TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(U31(tt, x0, x1, x2))) → TOP(mark(cons(x2, take(x1, x0))))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(mark(zeros)) → TOP(ok(zeros))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(take(0, x0))) → TOP(mark(U21(isNatIList(x0))))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(U11(and(isNatList(x1), isNat(x0)), x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(ok(and(tt, zeros))) → TOP(mark(zeros))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))
TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(s(x1)) → s(proper(x1))
proper(length(x1)) → length(proper(x1))
proper(U21(x1)) → U21(proper(x1))
proper(nil) → ok(nil)
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(isNat(x1)) → isNat(proper(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
isNat(ok(x1)) → ok(isNat(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
U21(mark(x1)) → mark(U21(x1))
U21(ok(x1)) → ok(U21(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
active(cons(x1, x2)) → cons(active(x1), x2)
active(U11(x1, x2)) → U11(active(x1), x2)
active(s(x1)) → s(active(x1))
active(length(x1)) → length(active(x1))
active(U21(x1)) → U21(active(x1))
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))
active(and(x1, x2)) → and(active(x1), x2)

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 2 less nodes.

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ ForwardInstantiation

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

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

TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(U31(tt, x0, x1, x2))) → TOP(mark(cons(x2, take(x1, x0))))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(take(0, x0))) → TOP(mark(U21(isNatIList(x0))))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(length(cons(x0, x1)))) → TOP(mark(U11(and(isNatList(x1), isNat(x0)), x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))
TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(s(x1)) → s(proper(x1))
proper(length(x1)) → length(proper(x1))
proper(U21(x1)) → U21(proper(x1))
proper(nil) → ok(nil)
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(isNat(x1)) → isNat(proper(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
isNat(ok(x1)) → ok(isNat(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
U21(mark(x1)) → mark(U21(x1))
U21(ok(x1)) → ok(U21(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
active(cons(x1, x2)) → cons(active(x1), x2)
active(U11(x1, x2)) → U11(active(x1), x2)
active(s(x1)) → s(active(x1))
active(length(x1)) → length(active(x1))
active(U21(x1)) → U21(active(x1))
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))
active(and(x1, x2)) → and(active(x1), x2)

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

TOP(ok(length(cons(x0, x1)))) → TOP(mark(U11(and(isNatList(x1), isNat(x0)), x1)))

The remaining pairs can at least be oriented weakly.

TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(U31(tt, x0, x1, x2))) → TOP(mark(cons(x2, take(x1, x0))))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(take(0, x0))) → TOP(mark(U21(isNatIList(x0))))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))
TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(TOP(x₁)) = x₁
POL(U11(x₁, x₂)) = 0
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 0
POL(active(x₁)) = 0
POL(and(x₁, x₂)) = 0
POL(cons(x₁, x₂)) = 0
POL(isNat(x₁)) = 0
POL(isNatIList(x₁)) = 0
POL(isNatList(x₁)) = 0
POL(length(x₁)) = 1
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(ok(x₁)) = x₁
POL(proper(x₁)) = 0
POL(s(x₁)) = 0
POL(take(x₁, x₂)) = 0
POL(tt) = 0
POL(zeros) = 0

The following usable rules [17] were oriented:

take(mark(x1), x2) → mark(take(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
isNat(ok(x1)) → ok(isNat(x1))
cons(mark(x1), x2) → mark(cons(x1, x2))
U21(mark(x1)) → mark(U21(x1))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
and(mark(x1), x2) → mark(and(x1, x2))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
U21(ok(x1)) → ok(U21(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
isNatIList(ok(x1)) → ok(isNatIList(x1))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
isNatList(ok(x1)) → ok(isNatList(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
take(x1, mark(x2)) → mark(take(x1, x2))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ ForwardInstantiation

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

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

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(U31(tt, x0, x1, x2))) → TOP(mark(cons(x2, take(x1, x0))))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(ok(take(0, x0))) → TOP(mark(U21(isNatIList(x0))))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(s(x1)) → s(proper(x1))
proper(length(x1)) → length(proper(x1))
proper(U21(x1)) → U21(proper(x1))
proper(nil) → ok(nil)
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(isNat(x1)) → isNat(proper(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
isNat(ok(x1)) → ok(isNat(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
U21(mark(x1)) → mark(U21(x1))
U21(ok(x1)) → ok(U21(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
active(cons(x1, x2)) → cons(active(x1), x2)
active(U11(x1, x2)) → U11(active(x1), x2)
active(s(x1)) → s(active(x1))
active(length(x1)) → length(active(x1))
active(U21(x1)) → U21(active(x1))
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))
active(and(x1, x2)) → and(active(x1), x2)

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

TOP(ok(U31(tt, x0, x1, x2))) → TOP(mark(cons(x2, take(x1, x0))))
TOP(ok(take(0, x0))) → TOP(mark(U21(isNatIList(x0))))

The remaining pairs can at least be oriented weakly.

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(TOP(x₁)) = x₁
POL(U11(x₁, x₂)) = 0
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 1
POL(active(x₁)) = 0
POL(and(x₁, x₂)) = 0
POL(cons(x₁, x₂)) = 0
POL(isNat(x₁)) = 0
POL(isNatIList(x₁)) = 0
POL(isNatList(x₁)) = 0
POL(length(x₁)) = 0
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(ok(x₁)) = x₁
POL(proper(x₁)) = 0
POL(s(x₁)) = 0
POL(take(x₁, x₂)) = 1
POL(tt) = 0
POL(zeros) = 0

The following usable rules [17] were oriented:

take(mark(x1), x2) → mark(take(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
isNat(ok(x1)) → ok(isNat(x1))
cons(mark(x1), x2) → mark(cons(x1, x2))
U21(mark(x1)) → mark(U21(x1))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
and(mark(x1), x2) → mark(and(x1, x2))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
U21(ok(x1)) → ok(U21(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
isNatIList(ok(x1)) → ok(isNatIList(x1))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
isNatList(ok(x1)) → ok(isNatList(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
take(x1, mark(x2)) → mark(take(x1, x2))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ ForwardInstantiation

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

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

TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))
TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(s(x1)) → s(proper(x1))
proper(length(x1)) → length(proper(x1))
proper(U21(x1)) → U21(proper(x1))
proper(nil) → ok(nil)
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(isNat(x1)) → isNat(proper(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
isNat(ok(x1)) → ok(isNat(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
U21(mark(x1)) → mark(U21(x1))
U21(ok(x1)) → ok(U21(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
active(cons(x1, x2)) → cons(active(x1), x2)
active(U11(x1, x2)) → U11(active(x1), x2)
active(s(x1)) → s(active(x1))
active(length(x1)) → length(active(x1))
active(U21(x1)) → U21(active(x1))
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))
active(and(x1, x2)) → and(active(x1), x2)

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

TOP(ok(U11(tt, x0))) → TOP(mark(s(length(x0))))

The remaining pairs can at least be oriented weakly.

TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(TOP(x₁)) = x₁
POL(U11(x₁, x₂)) = 1
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 0
POL(active(x₁)) = 0
POL(and(x₁, x₂)) = 0
POL(cons(x₁, x₂)) = 0
POL(isNat(x₁)) = 0
POL(isNatIList(x₁)) = 0
POL(isNatList(x₁)) = 0
POL(length(x₁)) = 0
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(ok(x₁)) = x₁
POL(proper(x₁)) = 0
POL(s(x₁)) = 0
POL(take(x₁, x₂)) = 0
POL(tt) = 0
POL(zeros) = 0

The following usable rules [17] were oriented:

take(mark(x1), x2) → mark(take(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
isNat(ok(x1)) → ok(isNat(x1))
cons(mark(x1), x2) → mark(cons(x1, x2))
U21(mark(x1)) → mark(U21(x1))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
and(mark(x1), x2) → mark(and(x1, x2))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
U21(ok(x1)) → ok(U21(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
isNatIList(ok(x1)) → ok(isNatIList(x1))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
isNatList(ok(x1)) → ok(isNatList(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
take(x1, mark(x2)) → mark(take(x1, x2))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ ForwardInstantiation

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

                                                          ↳ QDP

                                                            ↳ QDPOrderProof

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

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(s(x1)) → s(proper(x1))
proper(length(x1)) → length(proper(x1))
proper(U21(x1)) → U21(proper(x1))
proper(nil) → ok(nil)
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(isNat(x1)) → isNat(proper(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
isNat(ok(x1)) → ok(isNat(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
U21(mark(x1)) → mark(U21(x1))
U21(ok(x1)) → ok(U21(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
active(cons(x1, x2)) → cons(active(x1), x2)
active(U11(x1, x2)) → U11(active(x1), x2)
active(s(x1)) → s(active(x1))
active(length(x1)) → length(active(x1))
active(U21(x1)) → U21(active(x1))
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))
active(and(x1, x2)) → and(active(x1), x2)

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

TOP(ok(take(s(x0), cons(x1, x2)))) → TOP(mark(U31(and(isNatIList(x2), and(isNat(x0), isNat(x1))), x2, x0, x1)))

The remaining pairs can at least be oriented weakly.

TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))

Used ordering: Polynomial interpretation [25]:

POL(0) = 1
POL(TOP(x₁)) = x₁
POL(U11(x₁, x₂)) = 0
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 0
POL(active(x₁)) = 0
POL(and(x₁, x₂)) = 0
POL(cons(x₁, x₂)) = 0
POL(isNat(x₁)) = 0
POL(isNatIList(x₁)) = 0
POL(isNatList(x₁)) = 0
POL(length(x₁)) = 1
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(ok(x₁)) = x₁
POL(proper(x₁)) = 1 + x₁
POL(s(x₁)) = 0
POL(take(x₁, x₂)) = 1
POL(tt) = 0
POL(zeros) = 1

The following usable rules [17] were oriented:

take(mark(x1), x2) → mark(take(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
isNat(ok(x1)) → ok(isNat(x1))
cons(mark(x1), x2) → mark(cons(x1, x2))
U21(mark(x1)) → mark(U21(x1))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
and(mark(x1), x2) → mark(and(x1, x2))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
U21(ok(x1)) → ok(U21(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
isNatIList(ok(x1)) → ok(isNatIList(x1))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
isNatList(ok(x1)) → ok(isNatList(x1))
s(ok(x1)) → ok(s(x1))
length(mark(x1)) → mark(length(x1))
take(x1, mark(x2)) → mark(take(x1, x2))

↳ CSR

  ↳ Zantema-Transformation

  ↳ Incomplete Giesl Middeldorp-Transformation

  ↳ Improved Ferreira Ribeiro-Transformation

  ↳ Complete Giesl Middeldorp-Transformation

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ UsableRulesProof

                  ↳ QDP

                    ↳ QReductionProof

                      ↳ QDP

                        ↳ Narrowing

                          ↳ QDP

                            ↳ Narrowing

                              ↳ QDP

                                ↳ DependencyGraphProof

                                  ↳ QDP

                                    ↳ ForwardInstantiation

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ DependencyGraphProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

                                                          ↳ QDP

                                                            ↳ QDPOrderProof

                                                              ↳ QDP

                                                                ↳ QDPOrderProof

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

TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))

The TRS R consists of the following rules:

proper(zeros) → ok(zeros)
proper(cons(x1, x2)) → cons(proper(x1), proper(x2))
proper(0) → ok(0)
proper(U11(x1, x2)) → U11(proper(x1), proper(x2))
proper(tt) → ok(tt)
proper(s(x1)) → s(proper(x1))
proper(length(x1)) → length(proper(x1))
proper(U21(x1)) → U21(proper(x1))
proper(nil) → ok(nil)
proper(U31(x1, x2, x3, x4)) → U31(proper(x1), proper(x2), proper(x3), proper(x4))
proper(take(x1, x2)) → take(proper(x1), proper(x2))
proper(and(x1, x2)) → and(proper(x1), proper(x2))
proper(isNat(x1)) → isNat(proper(x1))
proper(isNatList(x1)) → isNatList(proper(x1))
proper(isNatIList(x1)) → isNatIList(proper(x1))
isNatIList(ok(x1)) → ok(isNatIList(x1))
isNatList(ok(x1)) → ok(isNatList(x1))
isNat(ok(x1)) → ok(isNat(x1))
and(mark(x1), x2) → mark(and(x1, x2))
and(ok(x1), ok(x2)) → ok(and(x1, x2))
take(mark(x1), x2) → mark(take(x1, x2))
take(x1, mark(x2)) → mark(take(x1, x2))
take(ok(x1), ok(x2)) → ok(take(x1, x2))
U31(mark(x1), x2, x3, x4) → mark(U31(x1, x2, x3, x4))
U31(ok(x1), ok(x2), ok(x3), ok(x4)) → ok(U31(x1, x2, x3, x4))
U21(mark(x1)) → mark(U21(x1))
U21(ok(x1)) → ok(U21(x1))
length(mark(x1)) → mark(length(x1))
length(ok(x1)) → ok(length(x1))
s(mark(x1)) → mark(s(x1))
s(ok(x1)) → ok(s(x1))
U11(mark(x1), x2) → mark(U11(x1, x2))
U11(ok(x1), ok(x2)) → ok(U11(x1, x2))
cons(mark(x1), x2) → mark(cons(x1, x2))
cons(ok(x1), ok(x2)) → ok(cons(x1, x2))
active(zeros) → mark(cons(0, zeros))
active(U11(tt, L)) → mark(s(length(L)))
active(U21(tt)) → mark(nil)
active(U31(tt, IL, M, N)) → mark(cons(N, take(M, IL)))
active(and(tt, X)) → mark(X)
active(isNat(0)) → mark(tt)
active(isNat(length(V1))) → mark(isNatList(V1))
active(isNat(s(V1))) → mark(isNat(V1))
active(isNatIList(V)) → mark(isNatList(V))
active(isNatIList(zeros)) → mark(tt)
active(isNatIList(cons(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(isNatList(nil)) → mark(tt)
active(isNatList(cons(V1, V2))) → mark(and(isNat(V1), isNatList(V2)))
active(isNatList(take(V1, V2))) → mark(and(isNat(V1), isNatIList(V2)))
active(length(nil)) → mark(0)
active(length(cons(N, L))) → mark(U11(and(isNatList(L), isNat(N)), L))
active(take(0, IL)) → mark(U21(isNatIList(IL)))
active(take(s(M), cons(N, IL))) → mark(U31(and(isNatIList(IL), and(isNat(M), isNat(N))), IL, M, N))
active(cons(x1, x2)) → cons(active(x1), x2)
active(U11(x1, x2)) → U11(active(x1), x2)
active(s(x1)) → s(active(x1))
active(length(x1)) → length(active(x1))
active(U21(x1)) → U21(active(x1))
active(U31(x1, x2, x3, x4)) → U31(active(x1), x2, x3, x4)
active(take(x1, x2)) → take(active(x1), x2)
active(take(x1, x2)) → take(x1, active(x2))
active(and(x1, x2)) → and(active(x1), x2)

The set Q consists of the following terms:

active(zeros)
active(isNat(0))
active(isNat(length(x0)))
active(isNat(s(x0)))
active(isNatIList(x0))
active(isNatList(nil))
active(isNatList(cons(x0, x1)))
active(isNatList(take(x0, x1)))
proper(zeros)
active(cons(x0, x1))
cons(mark(x0), x1)
proper(cons(x0, x1))
cons(ok(x0), ok(x1))
proper(0)
active(U11(x0, x1))
U11(mark(x0), x1)
proper(U11(x0, x1))
U11(ok(x0), ok(x1))
proper(tt)
active(s(x0))
s(mark(x0))
proper(s(x0))
s(ok(x0))
active(length(x0))
length(mark(x0))
proper(length(x0))
length(ok(x0))
active(U21(x0))
U21(mark(x0))
proper(U21(x0))
U21(ok(x0))
proper(nil)
active(U31(x0, x1, x2, x3))
U31(mark(x0), x1, x2, x3)
proper(U31(x0, x1, x2, x3))
U31(ok(x0), ok(x1), ok(x2), ok(x3))
active(take(x0, x1))
take(mark(x0), x1)
take(x0, mark(x1))
proper(take(x0, x1))
take(ok(x0), ok(x1))
active(and(x0, x1))
and(mark(x0), x1)
proper(and(x0, x1))
and(ok(x0), ok(x1))
proper(isNat(x0))
isNat(ok(x0))
proper(isNatList(x0))
isNatList(ok(x0))
proper(isNatIList(x0))
isNatIList(ok(x0))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].

The following pairs can be oriented strictly and are deleted.

TOP(ok(isNat(length(x0)))) → TOP(mark(isNatList(x0)))

The remaining pairs can at least be oriented weakly.

TOP(ok(isNatList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatList(x1))))
TOP(ok(and(x0, x1))) → TOP(and(active(x0), x1))
TOP(mark(isNatList(x0))) → TOP(isNatList(proper(x0)))
TOP(ok(isNatList(take(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(ok(isNatIList(cons(x0, x1)))) → TOP(mark(and(isNat(x0), isNatIList(x1))))
TOP(mark(s(x0))) → TOP(s(proper(x0)))
TOP(ok(and(tt, isNatList(y_0)))) → TOP(mark(isNatList(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(x0, active(x1)))
TOP(ok(and(tt, isNat(y_0)))) → TOP(mark(isNat(y_0)))
TOP(ok(take(x0, x1))) → TOP(take(active(x0), x1))
TOP(mark(U31(x0, x1, x2, x3))) → TOP(U31(proper(x0), proper(x1), proper(x2), proper(x3)))
TOP(ok(isNatIList(x0))) → TOP(mark(isNatList(x0)))
TOP(ok(and(tt, isNatIList(y_0)))) → TOP(mark(isNatIList(y_0)))
TOP(mark(cons(x0, x1))) → TOP(cons(proper(x0), proper(x1)))
TOP(ok(isNat(s(x0)))) → TOP(mark(isNat(x0)))
TOP(mark(and(x0, x1))) → TOP(and(proper(x0), proper(x1)))
TOP(ok(U21(x0))) → TOP(U21(active(x0)))
TOP(ok(U31(x0, x1, x2, x3))) → TOP(U31(active(x0), x1, x2, x3))
TOP(ok(length(x0))) → TOP(length(active(x0)))
TOP(ok(s(x0))) → TOP(s(active(x0)))
TOP(mark(U21(x0))) → TOP(U21(proper(x0)))
TOP(ok(and(tt, and(y_0, y_1)))) → TOP(mark(and(y_0, y_1)))
TOP(mark(take(x0, x1))) → TOP(take(proper(x0), proper(x1)))
TOP(mark(isNat(x0))) → TOP(isNat(proper(x0)))
TOP(mark(U11(x0, x1))) → TOP(U11(proper(x0), proper(x1)))
TOP(ok(U11(x0, x1))) → TOP(U11(active(x0), x1))
TOP(ok(cons(x0, x1))) → TOP(cons(active(x0), x1))
TOP(mark(length(x0))) → TOP(length(proper(x0)))
TOP(mark(isNatIList(x0))) → TOP(isNatIList(proper(x0)))

Used ordering: Polynomial interpretation [25]:

POL(0) = 0
POL(TOP(x₁)) = x₁
POL(U11(x₁, x₂)) = 1
POL(U21(x₁)) = 0
POL(U31(x₁, x₂, x₃, x₄)) = 0
POL(active(x₁)) = x₁
POL(and(x₁, x₂)) = x₂
POL(cons(x₁, x₂)) = 0
POL(isNat(x₁)) = 1 + x₁
POL(isNatIList(x₁)) = 0
POL(isNatList(x₁)) = 0
POL(length(x₁)) = 1
POL(mark(x₁)) = x₁
POL(nil) = 0
POL(ok(x₁)) = x₁
POL(proper(x₁)) = x₁
POL(s(x₁)) = x₁
POL(take(x₁, x₂)) = 0
POL(tt) = 0
POL(zeros) = 0

The